home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Tools / Languages / MacGambit 2.0 / sources1 / Runtime (.c & .h) / os_mac.c < prev    next >
Encoding:
Text File  |  1993-02-05  |  99.4 KB  |  2,557 lines  |  [TEXT/KAHL]
  1. ght - r.left ) >> 1 ) + SBarWidth + 1;
  2.   r.top = r.bottom - SBarWidth + 1;
  3.   SetPort( port );
  4.   InvalRect( &r );
  5. }
  6. static void inval_msgrect( short w )
  7. { if ( showPosnP ) wind_table[w].needs_inval_ticks = TickCount();
  8. }
  9. static void content( short id, EventRecord *event )
  10. { WindowPtr w = wind_table[id].wptr;
  11.   eTeHandle hTE = wind_table[id].hTE;
  12.   short cntlCode;
  13.   ControlHandle theControl;
  14.   ChPos oldCaret;
  15.  
  16.   SetPort( w );
  17.   ClipRect( &w->portRect );
  18.   GlobalToLocal( &event->where );
  19.   if ((cntlCode = FindControl( event->where, w, &theControl )) == 0 )
  20.   { if (PtInRect( event->where, &(**hTE).viewRect ))
  21.     { oldCaret = (**hTE).caretChPos;
  22.       eTeClick( hTE, event->where, event->modifiers, event->when );
  23.       if ( *(long *)&oldCaret != *(long *)&(**hTE).caretChPos ) inval_msgrect( id );
  24.     }
  25.   }
  26.   else if (cntlCode == inThumb)
  27.   { cntlCode = GetCtlValue( theControl );
  28.     TrackControl( theControl, event->where, 0L );
  29.     if ( ( cntlCode = GetCtlValue( theControl ) - cntlCode ) != 0 )
  30.         if( (**theControl).contrlRect.left < (**theControl).contrlRect.top ) /* horizontal? */
  31.             eTeScroll( hTE, cntlCode, 0, TRUE );
  32.         else
  33.             eTeScroll( hTE, 0, cntlCode, TRUE );
  34.   }
  35.   else
  36.     TrackControl( theControl, event->where, (ProcPtr )-1L );
  37. }
  38. #endif
  39.  
  40. /* 10Jan93  e -- added display of caret position */
  41. #if (eTe_SHOW_POSN == 0)
  42. static void update_window( short w )
  43. { GrafPtr port = wind_table[w].wptr;
  44.   Rect r = port->portRect;
  45. #ifdef USE_eTe_debug
  46.   Str255 tStr;
  47. #endif
  48.   r.right -= (( r.right - r.left ) >> 1 ) + SBarWidth + 1;
  49.   r.top = r.bottom - SBarWidth;
  50.   SetPort( port );
  51.   ClipRect( &port->portRect );    /* added for eTe  16Apr92  e  */
  52.   BeginUpdate( port );
  53.   EraseRect( &port->portRect );
  54.   DrawControls( port );
  55.   DrawGrowIcon( port );
  56.   EraseRect( &r );
  57.   MoveTo( r.left, r.top );
  58.   LineTo( r.right, r.top );
  59. #ifdef USE_eTe_debug
  60.   NumToString( eTeTextLength( wind_table[w].hTE ), tStr);
  61.   MoveTo( r.left + 4, r.bottom - 4 );
  62.   ClipRect( &r );
  63.   DrawString( (ConstStr255Param )tStr );
  64. #endif
  65.   eTeUpdate( wind_table[w].hTE );
  66.   EndUpdate( port );
  67. }
  68. #else
  69. static void update_window( short w )
  70. { GrafPtr port = wind_table[w].wptr;
  71.   Rect r = port->portRect;
  72.   Str255 tStr;
  73.   eTeHandle hTE;
  74.   r.right -= (( r.right - r.left ) >> 1 ) + SBarWidth + 1;
  75.   r.top = r.bottom - SBarWidth;
  76.   SetPort( port );
  77.   ClipRect( &port->portRect );    /* added for eTe  16Apr92  e  */
  78.   BeginUpdate( port );
  79.   EraseRect( &port->portRect );
  80.   DrawControls( port );
  81.   DrawGrowIcon( port );
  82.   EraseRect( &r );
  83.   MoveTo( r.left, r.top );
  84.   LineTo( r.right, r.top );
  85. #ifdef USE_eTe_debug
  86.   NumToString( eTeTextLength( wind_table[w].hTE ), tStr);
  87.   MoveTo( r.left + 4, r.bottom - 4 );
  88.   ClipRect( &r );
  89.   DrawString( (ConstStr255Param )tStr );
  90. #else
  91.   if ( showPosnP )
  92.   { hTE = wind_table[w].hTE;
  93.     MoveTo( r.left + 4, r.bottom - 4 );
  94.     ClipRect( &r );
  95.     NumToString( (long )(**hTE).caretChPos.v, tStr);
  96.     DrawString( (ConstStr255Param )tStr );
  97.     DrawString( "\p:" );
  98.     NumToString( (long )(**hTE).caretChPos.h, tStr);
  99.     DrawString( (ConstStr255Param )tStr );
  100.   }
  101. #endif
  102.   eTeUpdate( wind_table[w].hTE );
  103.   EndUpdate( port );
  104. }
  105. #endif
  106.  
  107. static void grow_window( id, p )
  108. short id;
  109. Point p;
  110. { WindowPtr w = wind_table[id].wptr;
  111.   long result;
  112.   short oScroll;
  113.   Rect r, oView;
  114.   
  115.   SetPort( w );
  116.  
  117.   /* 16Sep92  e  increase min size for H scroll bar
  118.   SetRect(&r, 80, 80, screenBits.bounds.right, screenBits.bounds.bottom); */
  119.   /* 13Oct92  e  per: bernard@sigi.cs.colorado.edu
  120.   SetRect(&r, 150, 80, screenBits.bounds.right, screenBits.bounds.bottom); */
  121.   r = (**GetGrayRgn()).rgnBBox;
  122.   r.top = 80;
  123.   r.left = 150;
  124.   /*  13Oct92  e  */
  125.   result = GrowWindow( w, p, &r );
  126.   if (result == 0) return;
  127.   SizeWindow( w, LoWord(result), HiWord(result), 1);
  128.  
  129.   InvalRect(&w->portRect);
  130.   setup_view( id );
  131.   HideControl( wind_table[id].vscroll );
  132.   MoveControl( wind_table[id].vscroll, w->portRect.right - SBarWidth, w->portRect.top-1);
  133.   SizeControl( wind_table[id].vscroll, SBarWidth+1, w->portRect.bottom - w->portRect.top-(SBarWidth-2));
  134.   HideControl( wind_table[id].hscroll );
  135.   MoveControl( wind_table[id].hscroll,
  136.                   w->portRect.right-((w->portRect.right-w->portRect.left)>>1),
  137.                   w->portRect.bottom - SBarWidth);
  138.   SizeControl( wind_table[id].hscroll,
  139.                   ((w->portRect.right-w->portRect.left)>>1)-(SBarWidth-1),
  140.                   SBarWidth+1);
  141.   ShowControl( wind_table[id].hscroll );
  142.   ValidRect(&(*wind_table[id].hscroll)->contrlRect );
  143.   ShowControl( wind_table[id].vscroll );
  144.   ValidRect(&(*wind_table[id].vscroll)->contrlRect );
  145.   update_window( id );
  146.   /* dunno (sometimes appropriate, sometimes not)... eTeShowCaret( wind_table[id].hTE ); */
  147. }
  148.  
  149. static void put_input( id, ptr, len, cr, flush, freshline )
  150. short id;
  151. char *ptr;
  152. short len;
  153. short cr, flush, freshline;
  154. { if (wind_table[id].in_use)
  155.   { long len1;
  156.     register long len2 = (wind_table[id].len - wind_table[id].pos);
  157.     register char *buf, *p1, *p2;
  158.     if ((len2 < 0) || flush) len2 = 0;
  159.     len1 = ((cr)?1:0) + len2 + (long)len;
  160.     buf = NewPtr( len1 );
  161.     if (buf == NULL) { SysBeep(10); return; }
  162.     p1 = buf;
  163.     p2 = wind_table[id].buf + wind_table[id].pos;
  164.     while (len2 > 0) { *p1++ = *p2++; len2--; }
  165.     p2 = ptr;
  166.     while (len > 0) { *p1++ = *p2++; len--; }
  167.     if (cr) *p1++ = '\r';
  168.     if (wind_table[id].buf != NULL) DisposPtr( wind_table[id].buf );
  169.     wind_table[id].buf = buf;
  170.     wind_table[id].pos = 0;
  171.     wind_table[id].len = len1;
  172.     if (freshline)
  173.     { eTeHandle hTE = wind_table[id].hTE;
  174.       if ( (**hTE).caretChPos.h > 0 ) check_TEInsert( "\r", 1L, hTE, 0 );
  175.       (**hTE).writeChPos = (**hTE).caretChPos; /*  9Jul92  e  */
  176.       eTeShowCaret( hTE );
  177.     }
  178.   }
  179. }
  180.  
  181. static void interrupt()
  182. { intr_action( 0L, 0L, "SIGINT" );
  183.   put_input( interaction_id, "", 0, 0, 1, 0 );
  184. }
  185.  
  186. static short open_file( filename, for_output, txt, io )
  187. Str255 filename;
  188. short for_output;
  189. short txt;
  190. short *io;
  191. { ioParam pb;
  192.   fileParam fp;
  193.   short refnum;
  194.   short len = (unsigned char)filename[0];
  195.   short file_existed = 1;
  196.  
  197.   pb.ioNamePtr = filename;
  198.   pb.ioVRefNum = current_volume;
  199.   pb.ioVersNum = 0;
  200.   pb.ioPermssn = ((for_output) ? fsRdWrPerm : fsRdPerm);
  201.   pb.ioMisc = 0;
  202.  
  203.   if (for_output)
  204.   { asm
  205.     { lea    pb,a0
  206.       _PBCreate
  207.     }
  208.     file_existed = (pb.ioResult == dupFNErr);
  209.     if ((pb.ioResult != noErr) && !file_existed)
  210.     { *io = pb.ioResult;  return -1; }
  211.   }
  212.   
  213.   asm
  214.   { lea    pb,a0
  215.     _PBOpen
  216.   }
  217.   if (pb.ioResult != noErr)
  218.   { if (for_output)
  219.       asm
  220.       { lea    pb,a0
  221.         _PBDelete
  222.       }
  223.     *io = pb.ioResult;
  224.     return -1;
  225.   }
  226.   refnum = pb.ioRefNum;
  227.   
  228.   if (!for_output) { *io = noErr; return refnum; }
  229.  
  230.   asm
  231.   { lea    pb,a0
  232.     _PBSetEOF
  233.   }
  234.  
  235.   if (!file_existed)
  236.   { fp.ioNamePtr = filename;
  237.     fp.ioVRefNum = current_volume;
  238.     fp.ioFVersNum = 0;
  239.     fp.ioFDirIndex = 0;
  240.     asm
  241.     { lea    fp,a0
  242.       _PBGetFInfo
  243.       bmi.s  @1
  244.     }
  245.     if (txt)
  246.       fp.ioFlFndrInfo.fdType = 'TEXT';
  247.     else
  248.       fp.ioFlFndrInfo.fdType = 'gamO';
  249.     fp.ioFlFndrInfo.fdCreator = 'gamI';
  250.     asm
  251.     { lea    fp,a0
  252.       _PBSetFInfo
  253.       @1
  254.     }
  255.   }
  256.  
  257.   *io = noErr;
  258.   return refnum;
  259. }
  260.  
  261. static short close_file( refnum, io )
  262. short refnum;
  263. short *io;
  264. { *io = FSClose( refnum );
  265.   return (*io != noErr);
  266. }
  267.  
  268. static short read_file( id, line, chr )
  269. short id;
  270. long line;
  271. long chr;
  272. { TeHANDLE hTE = wind_table[id].hTE;
  273.   short refnum;
  274.   short io, io2;
  275.   long pos = 0;
  276.   short result;
  277.   Rect r;
  278.   short beep = 0;
  279.   short text = 0;
  280.   long size, count;
  281.   ChPos chPos;
  282.   Handle hData;
  283.   
  284.   if ( line > 32768 )
  285.   { te_limit_err();
  286.     return 0;
  287.   }
  288.   chPos.v = (line==0) ? 0 : line-1;
  289.   chPos.h = (line==0) ? 0 : chr;
  290.  
  291.   SelectWindow( wind_table[id].wptr );
  292.  
  293.   if (wind_table[id].dirty)
  294.     if (!discard_changes( id )) return 0;
  295.   
  296.   refnum = open_file( wind_table[id].filename, 0, 1, &io );
  297.   if (refnum == -1)
  298.   { io_err( io );
  299.     return 0;
  300.   }
  301.  
  302.   eTeSetTextPtr( hTE, (Ptr )&text, 1L );
  303.   io = GetEOF(refnum, &size);
  304.   if( io == noErr )    {
  305.     if( hData = NewHandle( size + 1 ) )
  306.     {    HLock( hData );
  307.         count = size;
  308.         io = FSRead( refnum, &count, *hData );
  309.         HUnlock( hData );
  310.         if( ( io != noErr ) || ( count != size ) )
  311.         {    DisposHandle( hData );
  312.             if ( io == noErr ) io = ioErr;
  313.             /* io_err( io ); will happen */
  314.             /* added these next lines 7Jul92  e */
  315.             mem_full = 0;
  316.               eTeSetTextPtr( hTE, (Ptr )&text, 1L );
  317.         }
  318.         else
  319.         {    ((char *)*hData)[size] = '\0';
  320.             io = eTeSetTextHandleDetabify( hTE, hData, prefTabs );
  321.             if ( io == noErr )
  322.             {   count = eTeChPosToOffset( hTE, chPos );
  323.                 if ( count > 0 )
  324.                     eTeSetSelect( hTE, count-1, count );
  325.                 else
  326.                     eTeSetSelect( hTE, count, count );
  327.                 eTeShowCaret( hTE );
  328.             }
  329.             else
  330.             {    DisposHandle( hData );
  331.                 /* io_err( io ); will happen */
  332.                 /* added these next lines 7Jul92  e */
  333.                 mem_full = 0;
  334.                   eTeSetTextPtr( hTE, (Ptr )&text, 1L );
  335.             }
  336.           }
  337.       }
  338.       else
  339.       { mem_full = 0; io = mFulErr; }     /* mem_full = 0; added  7Jul92  e */
  340.   }
  341.  
  342.   if (close_file( refnum, &io2 ) || ((io != eofErr) && (io != noErr)))
  343.   { if ((io != eofErr) && (io != noErr)) io_err( io ); else io_err( io2 );
  344.       eSmudgeWindow( id );
  345.       return 0;
  346.   }
  347.   if (io != noErr)
  348.       eSmudgeWindow( id );
  349.   else
  350.       eUnSmudgeWindow( id, hTE );
  351.   return (io == noErr);
  352. }
  353.  
  354. static void write_file( id )
  355. short id;
  356. { TeHANDLE hTE = wind_table[id].hTE;
  357.   short refnum;
  358.   short io, io2;
  359.   long count;
  360.  
  361.   refnum = open_file( wind_table[id].filename, 1, 1, &io );
  362.   if (refnum == -1)
  363.   { io_err( io );
  364.     return;
  365.   }
  366.  
  367.   count = eTeTextLength( hTE );
  368.   io = FSWrite( refnum, &count, *((**hTE).hText) );
  369.  
  370.   if (close_file( refnum, &io2 ) || (io != noErr))
  371.   { if (io != noErr) io_err( io ); else io_err( io2 );
  372.     return;
  373.   }
  374.  
  375.   eUnSmudgeWindow( id, hTE );
  376. }
  377.  
  378. short edit( name, line, chr )
  379. char *name;
  380. long line;
  381. long chr;
  382. { short id;
  383.   Str255 pname;
  384.   c_to_p( name, pname );
  385.   if (pname[0] != '\0')
  386.   { for (id=0; id<MAX_NB_WINDOWS; id++)
  387.       if (wind_table[id].in_use && wind_table[id].is_file &&
  388.           (compare_p_to_p( wind_table[id].filename, pname ) == 0)) break;
  389.   }
  390.   else
  391.     id = MAX_NB_WINDOWS;
  392.  
  393.   if (id == MAX_NB_WINDOWS) id = wind_open( name, /* 27Jan93 e -- TRUE */ FALSE, TRUE, FALSE );
  394.   if (id < 0)
  395.     wind_err();
  396.   else
  397.   { wind_table[id].is_file = 1;
  398.     p_to_p( pname, wind_table[id].filename );
  399.     supress_mem_full_dialog = 1;        /* 27Jan93  e  */
  400.     if ( read_file( id, line, chr ) )
  401.         select_and_show( wind_table[id].wptr );
  402.     else
  403.         wind_close( id );
  404.     supress_mem_full_dialog = 0;        /* 27Jan93  e  */
  405.   }
  406.   return id;
  407. }
  408.  
  409. void save_as( id, path )
  410. short id;
  411. char *path;
  412. { Str255 ppath;
  413.   short i;
  414.   c_to_p( path, ppath );
  415.   for (i=0; i<MAX_NB_WINDOWS; i++)
  416.     if (wind_table[i].in_use && wind_table[i].is_file &&
  417.         (compare_p_to_p( wind_table[i].filename, ppath ) == 0))
  418.     { already_open_err( ppath );
  419.       return;
  420.     }
  421.   p_to_p( ppath, wind_table[id].filename );
  422.   if (wind_table[id].is_file) SetWTitle( wind_table[id].wptr, ppath );
  423.   if ( id != interaction_id ) /* 28Jan93  e  */
  424.   { delWindMenuItem( id );
  425.     addWindMenuItem( id );
  426.   }
  427.   write_file( id );
  428. }
  429.  
  430. static void wind_quit()
  431. { short id;
  432.   for (id=MAX_NB_WINDOWS-1; id>=0; id--)
  433.   { if (wind_table[id].in_use && wind_table[id].is_file && wind_table[id].dirty)
  434.     { if (!discard_changes( id )) return;
  435.       wind_close( id );
  436.     }
  437.   }
  438.   abnormal_exit = 0;
  439.   /* os_quit();    29Dec92  e  */
  440.   gDoQuit = 1;    /* 29Dec92  e  */
  441. }
  442.  
  443. static void handle_close( id )
  444. short id;
  445. { if (wind_table[id].is_file)
  446.   { if ((wind_table[id].dirty) && (!discard_changes( id ))) return;
  447.     wind_close( id );
  448.   }
  449.   else if (id != interaction_id)
  450.     put_input( id, "\004", 1, 0, 1, 0 );
  451. }
  452.  
  453. static char upcase( char c )
  454. { if( c >= 'a' &&  c <= 'z' ) return c - 0x20;
  455.   else return c;
  456. }
  457. /* 08Jan93  e  -- changed to return Boolean; added test for empty find string */
  458. Boolean find_next( id )
  459. short id;
  460. { TeHANDLE hTE = wind_table[id].hTE;
  461.   char *txt = *((**hTE).hText);
  462.   long pos = eTeChPosToOffset( hTE, (**hTE).selActive ? (**hTE).selEnd : (**hTE).caretChPos );
  463.   register char *start = txt + pos - 1;
  464.   register short len = (unsigned char)find_string[0];
  465.   register char *end = txt + eTeTextLength( hTE ) - len;
  466.   register short i;
  467.   Boolean again = TRUE;
  468.   Str255 ci_string;
  469.   if ( len == 0 ) goto not_found;
  470.   if( find_ci )
  471.   { for (i=len; i>0; i--)
  472.       ci_string[i] = upcase( find_string[i] );
  473.     /* ci_string[0] = len; -- not used */
  474.   }
  475.   find_begin:
  476.   while (start < end)
  477.   { if( find_ci )
  478.     { for (i=len; i>0; i--)
  479.         if( upcase( start[i] ) != (char )ci_string[i] ) goto next_pos;
  480.     }
  481.     else
  482.     { for (i=len; i>0; i--)
  483.         if (start[i] != (char )find_string[i]) goto next_pos;
  484.     }
  485.     eTeSetSelect( hTE, (long)(start-txt+1), (long)(start-txt+1+len) );
  486.     return 1;
  487.     next_pos:
  488.     start++;
  489.   }
  490.   if( find_wrap && again ) 
  491.   { start = txt;
  492.     end = start + pos - len;
  493.     again = FALSE;
  494.     goto find_begin;
  495.   }
  496. not_found:
  497.   SysBeep(10);
  498.   return 0;
  499. }
  500.  
  501. void replace_next( id )
  502. short id;
  503. { TeHANDLE hTE = wind_table[id].hTE;
  504.   if ( ! (**hTE).selActive )
  505.     SysBeep(10);
  506.   else
  507.   { long len = (unsigned char)replace_string[0];
  508.     check_TEInsert( ((char *)replace_string)+1, len, hTE, wind_table[id].bold_input );
  509.     find_next( id );
  510.     eTeShowCaret( hTE );
  511.   }
  512. }
  513.  
  514. /* 08Jan93  e  */
  515. void replace_all( id )
  516. short id;
  517. { TeHANDLE hTE = wind_table[id].hTE;
  518.   long len = (unsigned char)replace_string[0];
  519.   
  520.   if ( (**hTE).selActive )
  521.   { long pos = eTeChPosToOffset( hTE, (**hTE).selStart );
  522.     eTeSetSelect( hTE, pos, pos );
  523.   }
  524.   while ( find_next( id ) )
  525.     check_TEInsert( ((char *)replace_string)+1, len, hTE, wind_table[id].bold_input );
  526.   eTeShowCaret( hTE );
  527. }
  528.  
  529. static long balance( id, bal, prefix )
  530. short id;
  531. short bal;
  532. short prefix;
  533. {
  534.   return balance_bwd( wind_table[id].hTE, bal, prefix );
  535.   /* bulk of code moved to os_mac_eKeys.c  11Jul92  e */
  536. }
  537.  
  538. static void balance_next( id )
  539. short id;
  540. { TeHANDLE hTE = wind_table[id].hTE;
  541.   long start = balance( id, 0, 1 );
  542.   if (start < 0)
  543.     SysBeep(10);
  544.   else
  545.     eTeSetSelect( hTE, start,
  546.                      eTeChPosToOffset( hTE, (**hTE).selActive ?
  547.                                                   (**hTE).selEnd : (**hTE).caretChPos ) );
  548. }
  549.  
  550. static void online_help()
  551. {
  552.   help_show();
  553. }
  554.  
  555. static void find_dialog( short id )
  556. { DialogPtr dp;
  557.   short i, s;
  558.   Handle h;
  559.   Rect r;
  560.   eTePutScrap();                                          /*  13Oct92  e  */
  561.   ParamText( "\pFind:", "\pReplace with:", "\p", "\p" );
  562.   dp = GetNewDialog( find_dlogID, 0L, (WindowPtr)-1L );
  563.   if (dp == NULL) return;
  564.   GetDItem( dp, 3, &i, &h, &r );
  565.   SetIText( h, find_string );
  566.   GetDItem( dp, 5, &i, &h, &r );
  567.   SetIText( h, replace_string );
  568.   GetDItem( dp, 7, &i, &h, &r);
  569.   SetCtlValue( h, find_wrap );
  570.   GetDItem( dp, 8, &i, &h, &r);
  571.   SetCtlValue( h, find_ci );
  572.   SelIText( dp, 3, 0, find_string[0] );
  573.   SetCursor( &arrow );
  574.   do
  575.   { ModalDialog( 0L, &s );
  576.     switch( s )
  577.     { case 1:
  578.         GetDItem( dp, 3, &i, &h, &r );
  579.         GetIText( h, find_string );
  580.         GetDItem( dp, 5, &i, &h, &r );
  581.         GetIText( h, replace_string );
  582.         GetDItem( dp, 7, &i, &h, &r);
  583.         find_wrap = GetCtlValue( h );
  584.         GetDItem( dp, 8, &i, &h, &r);
  585.         find_ci   = GetCtlValue( h );
  586.         break;
  587.       case 7:
  588.       case 8:
  589.         GetDItem( dp, s, &i, &h, &r );
  590.         SetCtlValue( (ControlHandle )h, GetCtlValue( (ControlHandle )h ) ^ 1 );
  591.         break;
  592.     }
  593.   } while( s != 1 && s != 2 );
  594.   DisposDialog( dp );
  595.   if( s == 1 ) find_next( id );
  596.   eTeGetScrap();                                          /*  13Oct92  e  */
  597. }
  598.  
  599. /* 25Sep92  e  added print menu items */
  600.  
  601. static void handle_pgsetup( short id )
  602. { 
  603.   TeHANDLE hTE = wind_table[id].hTE;
  604.   SetCursor(&qd.arrow);
  605.   PageSetupDialog( hTE );
  606. }
  607.  
  608. /* 02Oct92  e  added iPrAbort check */
  609.  
  610. static void handle_print( short id )
  611. { 
  612.   OSErr err;
  613.   TeHANDLE hTE = wind_table[id].hTE;
  614.   Str255 flnm;
  615.   
  616.   SetCursor(&qd.arrow);
  617.   err = noErr;
  618.   if ( ! (**hTE).hPrint )
  619.     err = PageSetupDialog( hTE );
  620.   if( ! err )
  621.   {    pathstr_to_filename( wind_table[id].filename, flnm );
  622.     err = eTePrint( hTE, true, true, flnm );
  623.     eTePrint( nil, false, false, flnm );
  624.   }
  625.   if( err && err != userCanceledErr && err != iPrAbort ) io_err( err );
  626. }
  627.  
  628. /*----------------------------------------------------------------------*/
  629.  
  630. #include "struct.h"
  631.  
  632. #define MAC_HEAP_LEN_IN_K  50 /* leave at least 50K free for Mac heap */
  633. #define MAC_STACK_LEN_IN_K 26 /* leave this much stack space for Mac calls */
  634.  
  635. long link_stack_length_in_k = -1;
  636. long link_heap_length_in_k = -1;
  637. long link_const_length_in_k = -1;
  638.  
  639. struct mem_partition
  640. { long base_heap,  extend_heap,  spare_heap;
  641.   long base_const, extend_const, spare_const;
  642.   long base_zzzzz, extend_zzzzz, spare_zzzzz;
  643.   long base_mac,   extend_mac,   spare_mac;
  644.   long spare1, spare2, spare3, spare4;
  645. } memp;
  646.  
  647. long mem_cur_heap, mem_min_heap;
  648. long mem_cur_const, mem_min_const;
  649. long mem_cur_zzzzz, mem_min_zzzzz;
  650. long mem_cur_mac, mem_min_mac;
  651.  
  652. #define DEFAULT_EXTEND_HEAP  8
  653. #define DEFAULT_EXTEND_CONST 1
  654. #define DEFAULT_EXTEND_ZZZZZ 0
  655. #define DEFAULT_EXTEND_MAC   1
  656.  
  657. static void partition_init( ofiles_len )
  658. long ofiles_len; /* total length of object files */
  659. {
  660.   struct mem_partition **memph;
  661.   long initial_free_mem;
  662.   long stack_len, system_mem_less_const_len, processor_mem_len, fixed_len;
  663.   long free_mem_before_base, free_mem_after_base;
  664.   long total_extend, extend_heap, extend_const, extend_zzzzz, extend_mac;
  665.  
  666.  
  667.   memph = (struct mem_partition **)GetResource( 'gamP', 128 );
  668.   if ((memph != NULL) && (SizeResource(memph) == sizeof(struct mem_partition)))
  669.   { memp = **memph; ReleaseResource(memph); }
  670.   else
  671.     memp.base_heap = -1; /* forces initialization later on */
  672.  
  673.  
  674.   /* initial_free_mem is the total free space at present in the Mac's heap */
  675.  
  676.   initial_free_mem = ((long)&initial_free_mem) - ((long)HeapEnd);
  677.  
  678.  
  679.   /* compute amount of free memory before partitions are allocated */
  680.  
  681.   stack_len = ((long)DEFAULT_STACK_LENGTH_IN_K)*K;
  682.  
  683.   system_mem_less_const_len =
  684.     ceiling8( sizeof(struct sstate_rec) ) +
  685.     ((long)MAX_NB_GLOBALS)*sizeof(struct global_rec) +
  686.     ((long)MAX_NB_GLOBALS)*sizeof(short) +
  687.     ((long)NB_TRAPS)*sizeof(struct trap_rec);
  688.  
  689.   processor_mem_len =
  690.     stack_len*2 +
  691.     ceiling8( ((long)MAX_NB_EVENTS)*sizeof(long) ) +
  692.     ((long)LOCAL_HEAP_LENGTH_IN_K)*K +
  693.     ceiling8( ((long)MAX_NB_STATS)*sizeof(long) ) +
  694.     ceiling8( ((long)MAX_EMUL_CODE_LENGTH_IN_K)*K ) +
  695.     ceiling8( sizeof(struct pstate_rec) );
  696.  
  697.   fixed_len = ((long)MAC_STACK_LEN_IN_K*K)+system_mem_less_const_len+processor_mem_len;
  698.  
  699.   free_mem_before_base = (initial_free_mem - fixed_len)/K;
  700.  
  701.  
  702.   /* setup partitions */
  703.  
  704.   mem_min_heap  = (long)MIN_HEAP_LENGTH_IN_K;
  705.   mem_min_const = (ofiles_len+K-1)/K + (long)ADDITIONAL_CONST_LENGTH_IN_K;
  706.   mem_min_zzzzz = 0;
  707.   mem_min_mac   = (long)MAC_HEAP_LEN_IN_K;
  708.  
  709.   if ((memp.base_heap  < mem_min_heap ) || (memp.extend_heap  < 0) ||
  710.       (memp.base_const < mem_min_const) || (memp.extend_const < 0) ||
  711.       (memp.base_zzzzz < mem_min_zzzzz) || (memp.extend_zzzzz < 0) ||
  712.       (memp.base_mac   < mem_min_mac  ) || (memp.extend_mac   < 0) ||
  713.       (memp.base_heap+memp.base_const+memp.base_zzzzz+memp.base_mac > free_mem_before_base))
  714.   {
  715.     memp.base_heap  = mem_min_heap;   memp.extend_heap  = DEFAULT_EXTEND_HEAP;
  716.     memp.base_const = mem_min_const;  memp.extend_const = DEFAULT_EXTEND_CONST;
  717.     memp.base_zzzzz = mem_min_zzzzz;  memp.extend_zzzzz = DEFAULT_EXTEND_ZZZZZ;
  718.     memp.base_mac   = mem_min_mac;    memp.extend_mac   = DEFAULT_EXTEND_MAC;
  719.   }
  720.  
  721.   free_mem_after_base = free_mem_before_base -
  722.                         (memp.base_heap+memp.base_const+memp.base_zzzzz+memp.base_mac);
  723.   if (free_mem_after_base < 0) free_mem_after_base = 0;
  724.  
  725.   total_extend = memp.extend_heap+memp.extend_const+memp.extend_zzzzz+memp.extend_mac;
  726.   if (total_extend < 1) total_extend = 1; /* to avoid divide by 0 */
  727.  
  728.   extend_heap  = (free_mem_after_base*memp.extend_heap )/total_extend;
  729.   extend_const = (free_mem_after_base*memp.extend_const)/total_extend;
  730.   extend_zzzzz = (free_mem_after_base*memp.extend_zzzzz)/total_extend;
  731.   extend_mac   = free_mem_after_base - (extend_heap+extend_const+extend_zzzzz);
  732.  
  733.   mem_cur_heap  = memp.base_heap  + extend_heap;
  734.   mem_cur_const = memp.base_const + extend_const;
  735.   mem_cur_zzzzz = memp.base_zzzzz + extend_zzzzz;
  736.   mem_cur_mac   = memp.base_mac   + extend_mac;
  737.  
  738.  
  739.   link_stack_length_in_k = stack_len/K;
  740.   link_heap_length_in_k  = mem_cur_heap;
  741.   link_const_length_in_k = mem_cur_const;
  742. }
  743.  
  744. static long get_num_item( dp, item )
  745. DialogPtr dp;
  746. short item;
  747. { short i;
  748.   Rect r;
  749.   Handle h;
  750.   long n;
  751.   Str255 s;
  752.   GetDItem( dp, item, &i, &h, &r );
  753.   GetIText( h, s );
  754.   for (i=s[0]; i>0; i--) if ((s[i] < '0') || (s[i] > '9')) return -1;
  755.   StringToNum( s, &n );
  756.   if (n > 32767) return -1;
  757.   return n;
  758. }
  759.  
  760. static void set_num_item( dp, item, val )
  761. DialogPtr dp;
  762. short item;
  763. long val;
  764. { short i;
  765.   Rect r;
  766.   Handle h;
  767.   long n;
  768.   Str255 s;
  769.   NumToString( val, s );
  770.   GetDItem( dp, item, &i, &h, &r );
  771.   SetIText( h, s );
  772. }
  773.  
  774. static void partition_dialog()
  775. { Str255 s;
  776.   DialogPtr dp;
  777.   short i;
  778.   Handle h;
  779.   Rect r;
  780.  
  781.   long base_heap, extend_heap;
  782.   long base_const, extend_const;
  783.   long base_zzzzz, extend_zzzzz;
  784.   long base_mac, extend_mac;
  785.  
  786.   dp = GetNewDialog( partition_dlogID, 0L, (WindowPtr)-1L );
  787.   if (dp == NULL) return;
  788.  
  789.   SetCursor( &arrow );
  790.  
  791.   set_num_item( dp, 6,  mem_cur_heap );  set_num_item( dp, 7,  mem_min_heap );
  792.   set_num_item( dp, 12, mem_cur_const ); set_num_item( dp, 13, mem_min_const );
  793.   set_num_item( dp, 18, mem_cur_zzzzz ); set_num_item( dp, 19, mem_min_zzzzz );
  794.   set_num_item( dp, 24, mem_cur_mac );   set_num_item( dp, 25, mem_min_mac );
  795.  
  796.   base_heap  = memp.base_heap;  extend_heap  = memp.extend_heap;
  797.   base_const = memp.base_const; extend_const = memp.extend_const;
  798.   base_zzzzz = memp.base_zzzzz; extend_zzzzz = memp.extend_zzzzz;
  799.   base_mac   = memp.base_mac;   extend_mac   = memp.extend_mac;
  800.  
  801.   set_items:
  802.  
  803.   set_num_item( dp, 8,  base_heap );  set_num_item( dp, 9,  extend_heap );
  804.   set_num_item( dp, 14, base_const ); set_num_item( dp, 15, extend_const );
  805.   set_num_item( dp, 20, base_zzzzz ); set_num_item( dp, 21, extend_zzzzz );
  806.   set_num_item( dp, 26, base_mac );   set_num_item( dp, 27, extend_mac );
  807.  
  808.   SelIText( dp, 8, 0, 32767 );
  809.  
  810.   do
  811.   { ModalDialog( 0L, &i );
  812.     switch( i )
  813.     { case 1:
  814.         base_heap    = get_num_item( dp, 8 );
  815.         extend_heap  = get_num_item( dp, 9 );
  816.         base_const   = get_num_item( dp, 14 );
  817.         extend_const = get_num_item( dp, 15 );
  818.         base_zzzzz   = get_num_item( dp, 20 );
  819.         extend_zzzzz = get_num_item( dp, 21 );
  820.         base_mac     = get_num_item( dp, 26 );
  821.         extend_mac   = get_num_item( dp, 27 );
  822.         if ((base_heap  >= mem_min_heap ) && (extend_heap  >= 0) &&
  823.             (base_const >= mem_min_const) && (extend_const >= 0) &&
  824.             (base_zzzzz >= mem_min_zzzzz) && (extend_zzzzz >= 0) &&
  825.             (base_mac   >= mem_min_mac  ) && (extend_mac   >= 0))
  826.         {
  827.           if ((base_heap  != memp.base_heap ) || (extend_heap  != memp.extend_heap ) ||
  828.               (base_const != memp.base_const) || (extend_const != memp.extend_const) ||
  829.               (base_zzzzz != memp.base_zzzzz) || (extend_zzzzz != memp.extend_zzzzz) ||
  830.               (base_mac   != memp.base_mac  ) || (extend_mac   != memp.extend_mac  ))
  831.           {
  832.             struct mem_partition **memph;
  833.             memp.base_heap  = base_heap;  memp.extend_heap  = extend_heap;
  834.             memp.base_const = base_const; memp.extend_const = extend_const;
  835.             memp.base_zzzzz = base_zzzzz; memp.extend_zzzzz = extend_zzzzz;
  836.             memp.base_mac   = base_mac;   memp.extend_mac   = extend_mac;
  837.             memph = (struct mem_partition **)GetResource( 'gamP', 128 );
  838.             if ((memph != NULL) && (SizeResource(memph) == sizeof(struct mem_partition)))
  839.             {
  840.               **memph = memp;
  841.               ChangedResource(memph);
  842.               WriteResource(memph);
  843.               ReleaseResource(memph);
  844.             }
  845.           }
  846.           break;
  847.         }
  848.         else
  849.         {
  850.           SysBeep( 10 );
  851.           i = 0;
  852.           break;
  853.         }
  854.       case 2:
  855.         break;
  856.       case 3: ;
  857.         base_heap  = mem_min_heap;  extend_heap  = DEFAULT_EXTEND_HEAP;
  858.         base_const = mem_min_const; extend_const = DEFAULT_EXTEND_CONST;
  859.         base_zzzzz = mem_min_zzzzz; extend_zzzzz = DEFAULT_EXTEND_ZZZZZ;
  860.         base_mac   = mem_min_mac;   extend_mac   = DEFAULT_EXTEND_MAC;
  861.         goto set_items;
  862.     }
  863.   } while( i != 1 && i != 2 );
  864.   DisposDialog( dp );
  865. }
  866.  
  867. /*----------------------------------------------------------------------*/
  868.  
  869. static short handle_menu( result, id )
  870. long result;
  871. short id;
  872. { short theItem, theMenu, m, w;
  873.   MenuHandle mh;
  874.   WindowPeek wPtr;
  875.   Str255 name;
  876.  
  877.   theItem = LoWord( result );
  878.   theMenu = HiWord( result );
  879.   if (theMenu == 0) return 1;
  880.   mh = GetMHandle( theMenu );
  881.   for (m=appleM; m<=windowsM; m++) if (menus[m] == mh) break;
  882.   switch (m)
  883.   { case appleM:
  884.       if (theItem == 1)
  885.       { DialogPtr dp;
  886.         short i;
  887.         ParamText1( "\p" );
  888.         dp = GetNewDialog( about_dlogID, 0L, (WindowPtr)-1L );
  889.         if (dp != NULL)
  890.         { ModalDialog( 0L, &i );
  891.           DisposDialog( dp );
  892.         }
  893.       }
  894.       else if (theItem == 2)
  895.         online_help();
  896.       else
  897.       { GetItem(menus[appleM], theItem, &name);
  898.         OpenDeskAcc( &name );
  899.       }
  900.       break;
  901.     case fileM: 
  902.       switch (theItem)
  903.       { case newCommand:
  904.         { short w = wind_open( "Untitled", TRUE, TRUE, FALSE );
  905.           if (w < 0)
  906.             wind_err();
  907.           else
  908.             wind_table[w].is_file = 1;
  909.           break;
  910.         }
  911.         case openCommand:
  912.         { short i;
  913.           for (i=0; i<MAX_NB_WINDOWS; i++) if (!wind_table[i].in_use) break;
  914.           if (i == MAX_NB_WINDOWS)
  915.             wind_err();
  916.           else
  917.           { char path[FILENAME_LEN];
  918.             if (get_file( "\p", 1, "TEXT", path, FILENAME_LEN ))
  919.               edit( path, 0L, 0L );
  920.           }
  921.           break;
  922.         }
  923.         case closeCommand:
  924.           if (id >= 0)
  925.             handle_close( id );
  926.           else
  927.             help_hide_if_frontmost();
  928.           break;
  929.         case saveCommand:
  930.           if (id >= 0)
  931.             if (wind_table[id].is_file && (wind_table[id].filename[0] != '\0'))
  932.             { write_file( id );
  933.               break;
  934.             }
  935.         case saveasCommand:
  936.           if (id >= 0)
  937.           { char path[FILENAME_LEN];
  938.             Str255 flnm;
  939.             pathstr_to_filename( wind_table[id].filename, flnm );
  940.             if (put_file( "\pSave as:", flnm, path, FILENAME_LEN ))
  941.               save_as( id, path );
  942.           }
  943.           break;
  944.         case revertCommand:
  945.           if (id >= 0)
  946.             read_file( id, 0L, 0L );
  947.           break;
  948.         /* 25Sep92  e  added print menu items */
  949.         case pgsetupCommand:
  950.           if (id >= 0)
  951.             handle_pgsetup( id );
  952.           break;
  953.         case printCommand:
  954.           if (id >= 0)
  955.             handle_print( id );
  956.           break;
  957.         case quitCommand:
  958.           wind_quit();
  959.           if (gDoQuit) os_quit(); /* 29Dec92  e  */
  960.           break;
  961.       }
  962.       break;
  963.     /* 10Jan93  e  -- separated out Search menu */
  964.     case editM: 
  965.       if (id < 0)
  966.         SystemEdit(theItem-1);
  967.       else
  968.       { TeHANDLE hTE = wind_table[id].hTE;
  969.         switch (theItem)
  970.         { case undoCommand:
  971.             eTeUndo( hTE );
  972.             eMaybeSmudgeWindow( id, hTE );
  973.             break;
  974.           case cutCommand:
  975.             check_TECut( hTE );
  976.             eMaybeSmudgeWindow( id, hTE );
  977.             break;
  978.           case copyCommand:
  979.             check_TECopy( hTE );
  980.             break;
  981.           case pasteCommand:
  982.             check_TEPaste( hTE, wind_table[id].bold_input );
  983.             eMaybeSmudgeWindow( id, hTE );
  984.             break;
  985.           case clearCommand:
  986.             eTeDelete( hTE );
  987.             eMaybeSmudgeWindow( id, hTE );
  988.             break;
  989.           case selAllCommand:
  990.             eTeSetSelect( hTE, 0, eTeTextLength( hTE ));
  991.             break;
  992.           case balanceCommand:
  993.             balance_next( id );
  994.             break;
  995.           case smKeyBdCommand:
  996.               smKeyBdP ^= 1;
  997.               doKeyBdMode();
  998.               break;
  999.           case stylesCommand:
  1000.             eStyleDlg( hTE );
  1001.               break;
  1002.           case partitionCommand:
  1003.             partition_dialog();
  1004.               break;
  1005. #if (eTe_SHOW_POSN > 0)
  1006.           case showPosnCommand:    /* 10Jan93  e  */
  1007.               showPosnP ^= 1;
  1008.             CheckItem( menus[editM], showPosnCommand, showPosnP );
  1009.             for (w=0; w<MAX_NB_WINDOWS; w++)
  1010.                 if (wind_table[w].in_use) really_inval_msgrect( w );
  1011.               break;
  1012. #endif
  1013.           default: ;
  1014.         }
  1015.         eTeShowCaret( hTE );
  1016.       }
  1017.       break;
  1018.     case findM: 
  1019.       if (id >= 0)
  1020.       { TeHANDLE hTE = wind_table[id].hTE;
  1021.         switch (theItem)
  1022.         { case findCommand:
  1023.             find_dialog( id );
  1024.             break;
  1025.           case againCommand:
  1026.             find_next( id );
  1027.             break;
  1028.           case replaceCommand:
  1029.             replace_next( id );
  1030.             eMaybeSmudgeWindow( id, hTE );
  1031.             break;
  1032.           case fEnterCommand:
  1033.           { long sel_sta, sel_end, sel_len = 0;
  1034.             if( (**hTE).selActive ) {
  1035.               sel_sta = eTeChPosToOffset( hTE, (**hTE).selStart );
  1036.               sel_end = eTeChPosToOffset( hTE, (**hTE).selEnd );
  1037.               sel_len = sel_end - sel_sta;
  1038.             }
  1039.             if (sel_len > 0)
  1040.             { if( sel_len > 255 ) sel_len = 255;
  1041.               buf_to_p( (unsigned short)sel_len, *((**hTE).hText) + sel_sta, find_string );
  1042.             }
  1043.             else
  1044.               SysBeep( 1 );
  1045.             break;
  1046.           }
  1047.           case replaceAllCommand:    /* 08Jan93  e  */
  1048.             replace_all( id );
  1049.             eMaybeSmudgeWindow( id, hTE );
  1050.             break;
  1051.         }
  1052.         eTeShowCaret( hTE );
  1053.       }
  1054.       break;
  1055.     case commandM: 
  1056.       switch (theItem)
  1057.       { case helpCommand:
  1058.           put_input( interaction_id, " ,?", 3, 1, 1, 1 );
  1059.           break;
  1060.         case interruptCommand:
  1061.           interrupt();
  1062.           HiliteMenu(0);
  1063.           return 0;
  1064.         case returnCommand:
  1065.           put_input( interaction_id, " ,r", 3, 1, 1, 1 );
  1066.           break;
  1067.         case abortCommand:
  1068.           put_input( ((id < 0) || (wind_table[id].is_file))?interaction_id:id, "\004", 1, 0, 1, 0 );
  1069.           break;
  1070.         case toplevelCommand:
  1071.           put_input( interaction_id, " ,t", 3, 1, 1, 1 );
  1072.           break;
  1073.         case nextCommand:
  1074.           put_input( interaction_id, " ,+", 3, 1, 1, 1 );
  1075.           break;
  1076.         case previousCommand:
  1077.           put_input( interaction_id, " ,-", 3, 1, 1, 1 );
  1078.           break;
  1079.         case backtraceCommand:
  1080.           put_input( interaction_id, " ,b", 3, 1, 1, 1 );
  1081.           break;
  1082.         case procedureCommand:
  1083.           put_input( interaction_id, " ,i", 3, 1, 1, 1 );
  1084.           break;
  1085.         case expressionCommand:
  1086.           put_input( interaction_id, " ,y", 3, 1, 1, 1 );
  1087.           break;
  1088.         case localsCommand:
  1089.           put_input( interaction_id, " ,l", 3, 1, 1, 1 );
  1090.           break;
  1091.         default:
  1092.           break;
  1093.         }
  1094.       break;
  1095.     case windowsM:
  1096.       switch(theItem)
  1097.       { case 1:
  1098.           select_and_show( wind_table[interaction_id].wptr );
  1099.           break;
  1100.         case 2: /* blank line */
  1101.           break;
  1102.         default:
  1103.           theItem -= fustItem;
  1104.           if(theItem < qWindItems)
  1105.             SelectWindow( wind_table[itemtowindid[theItem]].wptr );
  1106.           break;
  1107.       }
  1108.       break;
  1109.     default:
  1110.       { char s[10], *p2 = s+10, *p1 = p2;
  1111.         do { *--p1 = (result%10)+'0'; result /= 10; } while (result > 0);
  1112.         put_input( interaction_id, " (mac#menuselection ", 21, 0, 1, 0 );
  1113.         put_input( interaction_id, p1, p2-p1, 0, 0, 0 );
  1114.         put_input( interaction_id, ")", 1, 1, 0, 1 );
  1115.         return 1;
  1116.       }
  1117.    }
  1118.   HiliteMenu(0);
  1119.   return 1;
  1120. }
  1121.  
  1122. static short do_tasks()
  1123. { short w;
  1124.   register short i;
  1125.   short men;
  1126.   EventRecord event;
  1127.   Rect r;
  1128.   RgnHandle rgn;
  1129. #if (eTe_SHOW_POSN > 0)
  1130.   long ticks = TickCount();
  1131. #endif
  1132.  
  1133.   for (i=0; i<MAX_NB_WINDOWS; i++)
  1134.     if (wind_table[i].in_use)
  1135.     { if (wind_table[i].out_len > 0)
  1136.       { HLock( wind_table[i].out_buf );    /* 10Jan93  e  */
  1137.         check_TEWrite( *wind_table[i].out_buf, (long)wind_table[i].out_len, wind_table[i].hTE, 0 );
  1138.         HUnlock( wind_table[i].out_buf );
  1139.         wind_table[i].out_len = 0;
  1140.       }
  1141. #if (eTe_SHOW_POSN > 0)
  1142.       /* 10Jan93  e -- added display of caret position */
  1143.       if ( wind_table[i].needs_inval_ticks != 0
  1144.            && ( wind_table[i].needs_inval_ticks + 15 ) < ticks )
  1145.       { really_inval_msgrect( i );
  1146.         wind_table[i].needs_inval_ticks = 0;
  1147.       }
  1148. #endif
  1149.     }
  1150.  
  1151.   w = wptr_to_id( FrontWindow() );
  1152.   if ( (!gInBackground) && (w >= 0) )
  1153.   { Point pt;
  1154.     Cursor *curs;
  1155.     OSEventAvail(0L, &event); /* This returns a NULL event with the global mouse location */
  1156.     if( gCursRgnOK && PtInRgn( event.where, gCursorRgn ) )
  1157.     { /* punt... SetCursor( current_cursor ); */
  1158.     }
  1159.     else
  1160.     { SetPort( (GrafPtr)wind_table[w].wptr );
  1161.       r = (**wind_table[w].hTE).viewRect;
  1162.       LocalToGlobal((Point *)&(r.top));      /* topLeft  */
  1163.       LocalToGlobal((Point *)&(r.bottom));   /* botRight */
  1164.       if (PtInRect( event.where, &r ))
  1165.       { curs = &ibeam_cursor;
  1166.         RectRgn(gCursorRgn, &r);
  1167.       }
  1168.       else
  1169.       { curs = &arrow;
  1170.         SetRectRgn(gCursorRgn, -32768, -32768, 32766, 32766);
  1171.         rgn = NewRgn();
  1172.         RectRgn(rgn, &r);
  1173.         DiffRgn(gCursorRgn, rgn, gCursorRgn);
  1174.         DisposeRgn(rgn);
  1175.       }
  1176.       if (!gCursRgnOK || current_cursor != curs)
  1177.       { current_cursor = curs;
  1178.         SetCursor( current_cursor );
  1179.       }
  1180.       gCursRgnOK = true;
  1181.     }
  1182.     eTeIdle( wind_table[w].hTE );
  1183.     men = (wind_table[w].is_file && (wind_table[w].filename[0] != '\0')) ? 1 : 0;
  1184.   }
  1185.   else
  1186.   { SetRectRgn(gCursorRgn, -32768, -32768, 32766, 32766);
  1187.     gCursRgnOK = false;
  1188.     SetCursor(&qd.arrow);    /*  13Oct92  e  */
  1189.     men = 2;
  1190.   }
  1191.  
  1192.   if ( (!gInBackground) && (men != current_menus) )
  1193.   { current_menus = men;
  1194.     switch (men)
  1195.     { case 0:
  1196.       case 1:
  1197.         /*
  1198.         EnableItem( menus[fileM], newCommand );
  1199.         EnableItem( menus[fileM], openCommand );
  1200.         EnableItem( menus[fileM], closeCommand );
  1201.         */
  1202.         EnableItem( menus[fileM], saveCommand );
  1203.         EnableItem( menus[fileM], saveasCommand );
  1204.         if (men == 0)
  1205.           DisableItem( menus[fileM], revertCommand );
  1206.         else
  1207.           EnableItem( menus[fileM], revertCommand );
  1208.         /*
  1209.         EnableItem( menus[fileM], quitCommand );
  1210.         */
  1211.         EnableItem( menus[fileM], pgsetupCommand );
  1212.         EnableItem( menus[fileM], printCommand );
  1213.         EnableItem( menus[editM], selAllCommand );
  1214.         EnableItem( menus[editM], balanceCommand );
  1215.         EnableItem( menus[editM], smKeyBdCommand );
  1216.         EnableItem( menus[editM], stylesCommand );
  1217.         EnableItem( menus[editM], partitionCommand );
  1218.         EnableItem( menus[editM], showPosnCommand );
  1219.         /*
  1220.         EnableItem( menus[findM], findCommand );
  1221.         EnableItem( menus[findM], againCommand );
  1222.         EnableItem( menus[findM], replaceCommand );
  1223.         EnableItem( menus[findM], replaceAllCommand );
  1224.         EnableItem( menus[findM], fEnterCommand ); */
  1225.         EnableItem( menus[findM], 0 );
  1226.         /*
  1227.         EnableItem( menus[commandM], 0 );
  1228.         */
  1229.         DrawMenuBar();
  1230.         break;
  1231.       case 2:
  1232.         /*
  1233.         DisableItem( menus[fileM], newCommand );
  1234.         DisableItem( menus[fileM], openCommand );
  1235.         DisableItem( menus[fileM], closeCommand );
  1236.         */
  1237.         DisableItem( menus[fileM], saveCommand );
  1238.         DisableItem( menus[fileM], saveasCommand );
  1239.         DisableItem( menus[fileM], revertCommand );
  1240.         /*
  1241.         DisableItem( menus[fileM], quitCommand );
  1242.         */
  1243.         DisableItem( menus[fileM], pgsetupCommand );
  1244.         DisableItem( menus[fileM], printCommand );
  1245.         DisableItem( menus[editM], selAllCommand );
  1246.         DisableItem( menus[editM], balanceCommand );
  1247.         DisableItem( menus[editM], smKeyBdCommand );
  1248.         DisableItem( menus[editM], stylesCommand );
  1249.         DisableItem( menus[editM], partitionCommand );
  1250.         DisableItem( menus[editM], showPosnCommand );
  1251.         /*
  1252.         DisableItem( menus[findM], findCommand );
  1253.         DisableItem( menus[findM], againCommand );
  1254.         DisableItem( menus[findM], replaceCommand );
  1255.         DisableItem( menus[findM], replaceAllCommand );
  1256.         DisableItem( menus[findM], fEnterCommand ); */
  1257.         DisableItem( menus[findM], 0 );
  1258.         /*
  1259.         DisableItem( menus[commandM], 0 );
  1260.         */
  1261.         DrawMenuBar();
  1262.         break;
  1263.     }
  1264.   }
  1265.  
  1266.   if ( (!gInBackground) && (w>=0) )
  1267.   { register EvQElPtr q;
  1268.     for (q = (EvQElPtr)EventQueue.qHead; q != NULL; q = (EvQElPtr)q->qLink)
  1269.       if ((q->evtQWhat == keyDown) && ((char)q->evtQMessage == '.') &&
  1270.           (q->evtQModifiers & cmdKey))
  1271.       { while (GetNextEvent(keyDownMask+keyUpMask+autoKeyMask,&event) &&
  1272.                !((event.what == keyDown) && ((event.message & charCodeMask) == '.') &&
  1273.                  ((event.modifiers & cmdKey) != 0) )) ;
  1274.         interrupt();
  1275.         return 0;
  1276.       }
  1277.   }
  1278.   return 1;
  1279. }
  1280.  
  1281. /* from MacDTS */
  1282. #define kDITop                    0x0050        /* kTopLeft - for positioning the Disk */
  1283. #define kDILeft                    0x0070        /*   Initialization dialogs. */
  1284.  
  1285. void handle_activate( WindowPtr wptr, Boolean activep )
  1286. { GrafPtr port;
  1287.   Rect r;
  1288.   short w = wptr_to_id( wptr );
  1289.   if( w >= 0 )
  1290.   { port = wind_table[w].wptr;
  1291.     r = port->portRect;
  1292.     r.left = r.right - (SBarWidth+1);
  1293.     SetPort( port );
  1294.     InvalRect( &r );
  1295.     r = port->portRect;
  1296.     r.top = r.bottom - (SBarWidth+1);
  1297.     InvalRect( &r );
  1298.     if ( activep )
  1299.     { eTeActivate( wind_table[w].hTE );
  1300.       ShowControl( wind_table[w].vscroll );
  1301.       ShowControl( wind_table[w].hscroll );
  1302.     }
  1303.     else
  1304.     { eTeDeactivate( wind_table[w].hTE );
  1305.       HideControl( wind_table[w].vscroll );
  1306.       HideControl( wind_table[w].hscroll );
  1307.     }
  1308.   }
  1309. }
  1310.  
  1311. static short handle_event( event )
  1312. EventRecord *event;
  1313. { register short i;
  1314.   short w;
  1315.   WindowPtr event_window;
  1316.  
  1317.   if (IsDialogEvent( event ))
  1318.   { DialogPtr dp;
  1319.     short item;
  1320.     DialogSelect( event, &dp, &item );
  1321.     return 1;
  1322.   }
  1323.  
  1324.   if (help_event( event )) return 1;
  1325.  
  1326.   w = wptr_to_id( FrontWindow() );
  1327.   { switch (event->what)
  1328.     { case mouseDown:
  1329.         gCursRgnOK = false;
  1330.         switch (FindWindow(event->where,&event_window))
  1331.         { case inDesk: 
  1332.             SysBeep( 10 );
  1333.             break;
  1334.           case inGoAway:
  1335.             if ((w = wptr_to_id( event_window )) >= 0)
  1336.               if (TrackGoAway(event_window,event->where)) handle_close( w );
  1337.             break;
  1338.           case inMenuBar:
  1339.           { TeHANDLE hTE = NULL;
  1340.             if( w >= 0) hTE = wind_table[w].hTE;
  1341.             eTeEditMenuUpdate( hTE, menus[editM] );
  1342.             return handle_menu( MenuSelect(event->where), w );
  1343.           }
  1344.           case inSysWindow:
  1345.             SystemClick(event,event_window);
  1346.             break;
  1347.           case inDrag:
  1348.             if ((w = wptr_to_id( event_window )) >= 0)
  1349.               DragWindow(event_window,event->where,&screenBits.bounds);
  1350.             break;
  1351.           case inGrow:
  1352.             if ((w = wptr_to_id( event_window )) >= 0)
  1353.               grow_window( w, event->where );
  1354.             break;
  1355.           case inContent:
  1356.             if (event_window != FrontWindow())
  1357.               SelectWindow(event_window);
  1358.             else 
  1359.               if ((w = wptr_to_id( event_window )) >= 0)
  1360.                 content( w, event );
  1361.             break;
  1362.           default: ;
  1363.         }
  1364.         gLastMouseDown = *event;
  1365.         break;
  1366.       case mouseUp:
  1367.         gLastMouseUp = *event;
  1368.         break;
  1369.       case keyDown:
  1370.       case autoKey:
  1371.         { char c = event->message & charCodeMask;
  1372.           TeHANDLE hTE = (w>=0)?wind_table[w].hTE:NULL;
  1373.           if ((c == '\r' /*cr*/) && ((event->modifiers & (cmdKey|optionKey)) != 0))
  1374.             event->modifiers = optionKey;
  1375.           else if( smKeyBdP )
  1376.           { /* hokey */
  1377.             if( (event->modifiers & optionKey) != 0 )
  1378.               { if( (event->modifiers & cmdKey) == 0 )
  1379.                   event->modifiers &= ~optionKey;    /* option key gets state of command key */
  1380.                 event->modifiers &= ~cmdKey;        /* turn off command key */
  1381.                 event->modifiers |= controlKey;        /* turn on  control key */
  1382.                 c -= 0x40;    /* its (close to) what control key would have done */
  1383.               }
  1384.           }
  1385.           if ((event->modifiers & cmdKey) != 0)
  1386.           { long res;
  1387.             if (c == '=') c = '+'; else if (c == '/') c = '?';
  1388.             if (hTE != NULL) eTeEditMenuUpdate( hTE, menus[editM] );
  1389.             res = MenuKey( c );
  1390.             if( HiWord( res ) != 0 )
  1391.                 return handle_menu( res, w );
  1392.             if( (hTE != NULL) && (c >= 0) && (c <= 31) )
  1393.             {   check_TEKey( c, hTE, 0, event );
  1394.                 inval_msgrect( w ); /* 10Jan93  e -- added display of caret position */
  1395.             }
  1396.             break;
  1397.           }
  1398.           if (hTE == NULL) break;
  1399.           if( ( event->modifiers & controlKey ) != 0 )
  1400.           { eEditCommand( hTE, c, event->modifiers, wind_table[w].bold_input );
  1401.               eMaybeSmudgeWindow( w, hTE );
  1402.               inval_msgrect( w );
  1403.           }
  1404.           else
  1405.           { if( ( c == 3 /*enter*/ ) || (( c == '\r' /*cr*/ ) && ((event->modifiers & optionKey) != 0 )))
  1406.             { short id = (wind_table[w].is_file) ? interaction_id : w;
  1407.               long sel_sta, sel_end, sel_len, dummy;
  1408.               if( (**hTE).selActive )
  1409.               { sel_sta = eTeChPosToOffset( hTE, (**hTE).selStart );
  1410.                   sel_end = eTeChPosToOffset( hTE, (**hTE).selEnd );
  1411.               }
  1412.               else
  1413.               { sel_end = eTeChPosToOffset( hTE, (**hTE).caretChPos );
  1414.                 if (c == 3 /*enter*/)
  1415.                     eTeGetRun( hTE, &sel_sta, &dummy );
  1416.                 else
  1417.                 { sel_sta = balance( w, 0, 1 );
  1418.                   if (sel_sta < 0) sel_sta = sel_end;
  1419.                 }
  1420.               }
  1421.               sel_len = sel_end - sel_sta;
  1422.               HLock((**hTE).hText);
  1423.               if (sel_len > 0)
  1424.               { eTeSetSelect( hTE, sel_end, sel_end );
  1425.                 put_input( id, *((**hTE).hText) + sel_sta, sel_len, 1, 0, 1 );
  1426.               }
  1427.               else
  1428.                 SysBeep(10);
  1429.               HUnlock((**hTE).hText);
  1430.             }
  1431.             else if (c == 9) /*tab*/
  1432.             { eTabCommand( hTE, event->modifiers, wind_table[w].bold_input );
  1433.               eMaybeSmudgeWindow( w, hTE );
  1434.               inval_msgrect( w ); /* 10Jan93  e -- added display of caret position */
  1435.             }
  1436.             else if( ( c == 127 /* del fwd */ )  || ( (c >= 0) && (c <= 31) ) )
  1437.             { check_TEKey( c, hTE, wind_table[w].bold_input, event );
  1438.               if ((c == '\r') && (**hTE).autoInd)
  1439.                 eTabCommand( hTE, event->modifiers, wind_table[w].bold_input );
  1440.               eMaybeSmudgeWindow( w, hTE );
  1441.               inval_msgrect( w ); /* 10Jan93  e -- added display of caret position */
  1442.             }
  1443.             else
  1444.             { if (!check_TEKey( c, hTE, wind_table[w].bold_input, event ))
  1445.                 if (c == ')')
  1446.                 { long open_paren = balance( w, 0, 0 );
  1447.                   if (open_paren >= 0)
  1448.                   { long now;
  1449.                     long selstart = eTeChPosToOffset( hTE, (**hTE).caretChPos );
  1450.                     eTeSetSelect( hTE, open_paren, open_paren+1 );
  1451.                     eTeShowCaret( hTE );
  1452.                     now = TickCount();
  1453.                     while ((TickCount()-now)<10) ;
  1454.                     while (!EventAvail(everyEvent,event) && ((TickCount()-now)<30)) ;
  1455.                     eTeSetSelect( hTE, selstart, selstart );
  1456.                   }
  1457.                 }
  1458.               eMaybeSmudgeWindow( w, hTE );
  1459.               inval_msgrect( w ); /* 10Jan93  e -- added display of caret position */
  1460.               eTeShowCaret( hTE );
  1461.             }
  1462.           }
  1463.         }
  1464.         break;
  1465.       case activateEvt:
  1466.         gCursRgnOK = false;
  1467.           handle_activate( (WindowPtr)event->message, ((event->modifiers & activeFlag) != 0) );
  1468.         break;
  1469.       case updateEvt: 
  1470.         if ((w = wptr_to_id( (WindowPtr)event->message )) >= 0)
  1471.         { update_window(w);
  1472.         }
  1473.         else
  1474.         { GrafPtr port = (WindowPtr)event->message;
  1475.           SetPort( port );
  1476.           BeginUpdate( port );
  1477.           EndUpdate( port );
  1478.         }
  1479.         break;
  1480.       case osEvt:
  1481.         if( *(char *)(&event->message) == suspendResumeMessage )
  1482.         { gCursRgnOK = false; /* Suspend/resume is also an activate/deactivate. */
  1483.           gInBackground = !(event->message & resumeFlag);
  1484.           if( gInBackground ) eTePutScrap();                  /*  13Aug92  e  */
  1485.           else                  eTeGetScrap();                  /*  13Aug92  e  */
  1486.           handle_activate( FrontWindow(), !gInBackground );
  1487.         }
  1488.         /* punt mouseMovedMessage */
  1489.         break;
  1490.       case diskEvt:
  1491.         gCursRgnOK = false;                     /* It is not a bad idea to at least call */
  1492.         if (HiWord(event->message) != noErr) /* DIBadMount in response to a diskEvt,  */
  1493.         { Point pt;                             /* so that the user can format a floppy. */
  1494.           SetPt( &pt, kDILeft, kDITop );
  1495.           DIBadMount( pt, event->message );
  1496.         }
  1497.         break;
  1498.       /* 29Dec92  e  */
  1499.       case kHighLevelEvent:
  1500.         AEProcessAppleEvent(event);
  1501.         if (gDoQuit) os_quit();
  1502.         break;
  1503.       default: ;
  1504.     }
  1505.   }
  1506.   return 1;
  1507. }
  1508.  
  1509. static long wind_read( id, ptr, n )
  1510. short id;
  1511. char *ptr;
  1512. long n;
  1513. { if (n > 0)
  1514.   { register short len;
  1515.     if ((len = wind_table[id].len - wind_table[id].pos) > 0)
  1516.     { register char *p1 = ptr;
  1517.       register char *p2 = wind_table[id].buf + wind_table[id].pos;
  1518.       register short i = 0;
  1519.       if (p2[i] == '\004') { wind_table[id].pos++; return 0; }
  1520.       if (len > n) len = n;
  1521.       while ((i < len) && (p2[i] != '\004'))
  1522.       { register char c = p2[i++];
  1523.         if (c == '\r') c = '\n';
  1524.         *p1++ = c;
  1525.       }
  1526.       wind_table[id].pos += i;
  1527.       return i;
  1528.     }
  1529.     else
  1530.       return -2;
  1531.   }
  1532.   else
  1533.     return 0;
  1534. }
  1535.  
  1536. static long wind_write( id, ptr, n )
  1537. short id;
  1538. char *ptr;
  1539. long n;
  1540. { register char *p1 = ptr, *p2 = ptr+n;
  1541.   register short len = wind_table[id].out_len;
  1542.   register char *p3; /*  = wind_table[id].out_buf; */
  1543.   /* 10Jan93  e  */
  1544.   if( wind_table[id].out_buf == NULL )
  1545.   { wind_table[id].out_buf = NewHandle( OUT_BUF_LEN );
  1546.     if( wind_table[id].out_buf == NULL )
  1547.     { SysBeep(10);
  1548.       return 0;
  1549.     }
  1550.   }
  1551.   HLock( wind_table[id].out_buf );
  1552.   p3 = (char *)*wind_table[id].out_buf;
  1553.  
  1554.   if (!((WindowPeek)wind_table[id].wptr)->visible)
  1555.     select_and_show( wind_table[id].wptr );
  1556.  
  1557.   while (p1<p2)
  1558.   { register char c = *p1++;
  1559.     if (c == '\n') { p3[len++] = '\r'; goto output; }
  1560.     p3[len++] = c;
  1561.     if (len == OUT_BUF_LEN)
  1562.     { output:
  1563.       if (check_TEWrite( p3, (long)len, wind_table[id].hTE, 0 )) goto werror;
  1564.       wind_table[id].out_len = 0;
  1565.       len = 0;
  1566.     }
  1567.   }
  1568.   wind_table[id].out_len = len;
  1569. werror:
  1570.   HUnlock( wind_table[id].out_buf );
  1571.   return n;
  1572. }
  1573.  
  1574. /*--------------------------------------------------------------------------*/
  1575.  
  1576. /* new stuff  29Dec92  e  */
  1577.  
  1578. /* Used to check for any unread required parameters. Returns true if we
  1579. ** missed at least one. */
  1580.  
  1581. static Boolean    MissedAnyParameters(AppleEvent *message)
  1582. {
  1583.     OSErr        err;
  1584.     DescType    ignoredActualType;
  1585.     AEKeyword    missedKeyword;
  1586.     Size        ignoredActualSize;
  1587.     EventRecord    event;
  1588.  
  1589.     err = AEGetAttributePtr(    /* SEE IF PARAMETERS ARE ALL USED UP.          */
  1590.         message,                /* AppleEvent to check.                          */
  1591.         keyMissedKeywordAttr,    /* Look for unread parameters.                  */
  1592.         typeWildCard,            /* So we can see what type we missed, if any. */
  1593.         &ignoredActualType,        /* What it would have been if not coerced.      */
  1594.         (Ptr)&missedKeyword,    /* Data area.  (Keyword not handled.)          */
  1595.         sizeof(missedKeyword),    /* Size of data area.                          */
  1596.         &ignoredActualSize        /* Actual data size.                          */
  1597.     );
  1598.  
  1599. /* No error means that we found some unused parameters. */
  1600.  
  1601.     if (err == noErr) {
  1602.         event.message = *(long *) &ignoredActualType;
  1603.         event.where = *(Point *) &missedKeyword;
  1604.         err = errAEEventNotHandled;
  1605.     }
  1606.  
  1607. /* errAEDescNotFound means that there are no more parameters.  If we get
  1608. ** an error code other than that, flag it. */
  1609.  
  1610.     return(err != errAEDescNotFound);
  1611. }
  1612.  
  1613. static OSErr    OpenDocEventHandler(AppleEvent *message, AppleEvent *reply, short mode)
  1614. {
  1615.     OSErr        err;
  1616.     OSErr        err2;
  1617.     AEDesc        theDesc;
  1618.     FSSpec        theFSS;
  1619.     short        loop;
  1620.     long        numFilesToOpen;
  1621.     AEKeyword    ignoredKeyWord;
  1622.     DescType    ignoredType;
  1623.     Size        ignoredSize;
  1624.     char path[512];
  1625.     short w;
  1626.     Str255 flnm;
  1627.     FInfo theFInfo;
  1628.  
  1629.     theDesc.dataHandle = nil;
  1630.         /* Make sure disposing of the descriptors is okay in all cases.
  1631.         ** This will not be necessary after 7.0b3, since the calls that
  1632.         ** attempt to create the descriptors will nil automatically
  1633.         ** upon failure. */
  1634.  
  1635.     if ( err = AEGetParamDesc( message, keyDirectObject, typeAEList, &theDesc ) )
  1636.         return(err);
  1637.  
  1638.     if ( ! MissedAnyParameters( message ) ) {
  1639.  
  1640. /* Got all the parameters we need.  Now, go through the direct object,
  1641. ** see what type it is, and parse it up. */
  1642.  
  1643.         err = AECountItems(&theDesc, &numFilesToOpen);
  1644.         if (!err)
  1645.         {    /* We have numFilesToOpen that need opening, as either a window
  1646.             ** or to be printed.  Go to it... */
  1647.  
  1648.             for (loop = 1; ((loop <= numFilesToOpen) && (!err)); ++loop)
  1649.             {    err = AEGetNthPtr(        /* GET NEXT IN THE LIST...         */
  1650.                     &theDesc,            /* List of file names.             */
  1651.                     loop,                /* Item # in the list.             */
  1652.                     typeFSS,            /* Item is of type FSSpec.         */
  1653.                     &ignoredKeyWord,    /* Returned keyword -- we know.  */
  1654.                     &ignoredType,        /* Returned type -- we know.     */
  1655.                     (Ptr)&theFSS,        /* Where to put the FSSpec info. */
  1656.                     sizeof(theFSS),        /* Size of the FSSpec info.         */
  1657.                     &ignoredSize        /* Actual size -- we know.         */
  1658.                 );
  1659.                 if (err) break;
  1660.  
  1661.                 FSpGetFInfo( &theFSS, &theFInfo );
  1662.                 if ( theFInfo.fdType != 'TEXT' )
  1663.                 { SysBeep( 3 );
  1664.                   continue;
  1665.                 }
  1666.  
  1667.                 gPrintPage = mode;
  1668.                     /* Open the window off-screen if we are printing.
  1669.                     ** We use the gPrintPage global to flag this.  Normally, the
  1670.                     ** gPrintPage global is to tell ImageDocument if we are imaging
  1671.                     ** to the window or to paper.  We don't need it for this yet,
  1672.                     ** as we can't image the document until it is opened.  DoNewWindow()
  1673.                     ** uses gPrintPage as a flag to open the window off-screen, but
  1674.                     ** visible, so that PrintMonitor can use the title of the window
  1675.                     ** as the document name that is being printed. */
  1676.                 
  1677.                 if ( getfullpath( theFSS.vRefNum, theFSS.parID, theFSS.name, path, 511, 1 ) )
  1678.                 {    
  1679.                     w = edit( path, 0L, 0L );
  1680.  
  1681.                     if ( gPrintPage && w >= 0 )
  1682.                     {    pathstr_to_filename( wind_table[w].filename, flnm );
  1683.                         err  = eTePrint( wind_table[w].hTE, (mode == 2), (loop == 1), flnm );
  1684.                         mode = 1;    /* No interaction mode (mode == 2) only valid
  1685.                                     ** for the first printed document. */
  1686.                         wind_close( w );
  1687.                     }
  1688.                 }
  1689.                 else err = errAEEventNotHandled;     /* file pathname too long */
  1690.             }
  1691.             if (gPrintPage)
  1692.             {    eTePrint( nil, false, false, flnm ); /* cleanup */
  1693.                 gPrintPage = 0;                     /* back to normal */
  1694.             }
  1695.         }
  1696.     }
  1697.     err2 = AEDisposeDesc(&theDesc);
  1698.     return(err ? err : err2);
  1699. }
  1700.  
  1701. static Boolean install_aehandler( AEEventClass cl, AEEventID id, ProcPtr p )
  1702. { OSErr    err;
  1703.   err = AEInstallEventHandler( cl, id, p, 0L, false );
  1704.   if (err)
  1705.   { io_err(err);
  1706.     return false;
  1707.   }
  1708.   return true;
  1709. }
  1710.  
  1711. static pascal OSErr    DoAEOpenApplication( AppleEvent *message, AppleEvent *reply, long refcon )
  1712. {
  1713.     return(noErr);
  1714. }
  1715.  
  1716. static pascal OSErr    DoAEOpenDocuments( AppleEvent *message, AppleEvent *reply, long refcon )
  1717. {
  1718.     gCursRgnOK = false;
  1719.     return( OpenDocEventHandler( message, reply, 0 ) ); /* 0 means regular open document */
  1720. }
  1721.  
  1722. #define kTimeOutInTicks (60 * 30)    /* 30 second timeout. */
  1723.  
  1724. static pascal OSErr    DoAEPrintDocuments(AppleEvent *message, AppleEvent *reply, long refcon)
  1725. {
  1726.     short                openMode;
  1727.     ProcessSerialNumber    cpsn, fpsn;
  1728.     Boolean                procsSame;
  1729.  
  1730.     gCursRgnOK = false;
  1731.     openMode = 1;
  1732.     if (!AEInteractWithUser(kTimeOutInTicks, nil, nil))
  1733.         ++openMode;
  1734.  
  1735.     GetCurrentProcess(&cpsn);        /* We may have been moved to the front. */
  1736.     GetFrontProcess(&fpsn);
  1737.     SameProcess(&cpsn, &fpsn, &procsSame);
  1738.     gInBackground = !procsSame;
  1739.  
  1740.     return( OpenDocEventHandler( message, reply, openMode ) );
  1741.         /* openMode is either 1 or 2, depending if user interaction is okay. */
  1742. }
  1743.  
  1744. static pascal OSErr    DoAEQuitApplication( AppleEvent *message, AppleEvent *reply, long refcon )
  1745. {
  1746.     gCursRgnOK = false;
  1747.     wind_quit();
  1748.     return( gDoQuit ? noErr : errAEEventNotHandled );
  1749. }
  1750.  
  1751. /* 1Feb93  e  --  DoScript added */
  1752.  
  1753. static OSErr DoScriptAsFile( FSSpec *theFSS )
  1754. {
  1755.     OSErr err = noErr;
  1756.     short len;
  1757.     char  path[512];
  1758.     
  1759.     if( len = getfullpath( theFSS->vRefNum, theFSS->parID, theFSS->name, path, 511, 1 ) )
  1760.     {
  1761.         put_input( interaction_id, " (load \"", 6, 0, 0, 1 );
  1762.         put_input( interaction_id, path, len, 0, 0, 0 );
  1763.         put_input( interaction_id, "\")", 2, 1, 0, 0 );
  1764.     }
  1765.     else err = errAEEventNotHandled;
  1766.     return err;
  1767. }
  1768.  
  1769. static pascal OSErr DoAEDoScript( AppleEvent *theAEEvent, AppleEvent *theAEReply, long *theRefCon)
  1770. {
  1771.     OSErr        theErr;
  1772.     DescType    typeCode;
  1773.     Size        sizeOfParam, actualSize;
  1774.     char        ourScriptText[256];
  1775.     FSSpec        ourScriptFSpec;
  1776.  
  1777.     /* Get the script to run */ 
  1778.  
  1779.     theErr = AESizeOfParam( theAEEvent, keyDirectObject, &typeCode, &sizeOfParam);
  1780.     if (theErr != noErr)
  1781.     {    /*
  1782.             If we fail here just return the error. We don't need to do any clean up since 
  1783.             we've allocated nothing on the heap yet.  The Apple Event Manager automatically 
  1784.             adds the error number to the reply as keyErrorNumber for non zero handler returns.
  1785.         */
  1786.         return theErr;
  1787.     }
  1788.     else if ((typeCode == typeChar) || (typeCode == typeStyledText) || (typeCode == typeIntlText))
  1789.     {
  1790.         theErr = AEGetParamPtr( theAEEvent, keyDirectObject, typeChar, &typeCode,
  1791.                                  (Ptr)&ourScriptText, sizeof(ourScriptText), &actualSize);
  1792.         if (theErr == noErr)
  1793.             if ( MissedAnyParameters( theAEEvent ) )
  1794.                 theErr = errAEEventNotHandled;
  1795.             else put_input( interaction_id, ourScriptText, actualSize, 1, 0, 1 );
  1796.     }
  1797.     else if (typeCode == typeAlias)
  1798.     {
  1799.         theErr = AEGetParamPtr( theAEEvent, keyDirectObject, typeFSS, &typeCode,
  1800.                                 (Ptr)&ourScriptFSpec, sizeof(ourScriptFSpec), &actualSize);
  1801.         if ( theErr == noErr )
  1802.             if ( MissedAnyParameters( theAEEvent ) )
  1803.                 theErr = errAEEventNotHandled;
  1804.             else theErr = DoScriptAsFile( &ourScriptFSpec );
  1805.     }
  1806.     else theErr = errAEEventNotHandled;
  1807.     return theErr;
  1808. }
  1809.  
  1810.  
  1811. static void init_ae()
  1812. {
  1813.     long    result;
  1814.  
  1815.     gHasAppleEvents = (Gestalt(gestaltAppleEventsAttr, &result) ? false : result != 0);
  1816.  
  1817.     if (gHasAppleEvents)
  1818.          install_aehandler( kCoreEventClass, kAEOpenApplication, (ProcPtr)DoAEOpenApplication )
  1819.       && install_aehandler( kCoreEventClass, kAEOpenDocuments, (ProcPtr)DoAEOpenDocuments )
  1820.       && install_aehandler( kCoreEventClass, kAEPrintDocuments, (ProcPtr)DoAEPrintDocuments )
  1821.       && install_aehandler( kCoreEventClass, kAEQuitApplication, (ProcPtr)DoAEQuitApplication )
  1822.       && install_aehandler( kAEMiscStandards, kAEDoScript, (ProcPtr)DoAEDoScript );
  1823. }
  1824.  
  1825. /*---------------------------------------------------------------------------*/
  1826.  
  1827. #define TICKS_PER_SEC 60
  1828.  
  1829. short *link_ofiles[] =
  1830. { (short *)"      ", (short *)"      ", (short *)"      ", (short *)"      ",
  1831.   (short *)"      ", (short *)"      ", (short *)"      ", (short *)"      ",
  1832.   (short *)"      ", (short *)"      ", (short *)"      ", (short *)"      ",
  1833.   (short *)"      ", (short *)"      ", (short *)"      ", (short *)"      ",
  1834.   (short *)"      ", (short *)"      ", (short *)"      ", (short *)"      ",
  1835.   (short *)"      ", (short *)"      ", (short *)"      ", (short *)"      ",
  1836.   (short *)"      ", (short *)"      ", (short *)"      ", (short *)"      ",
  1837.   (short *)"      ", (short *)"      ", (short *)"      ", (short *)"      ",
  1838.   (short *)"      ", (short *)"      ", (short *)"      ", (short *)"      ",
  1839.   (short *)"      ", (short *)"      ", (short *)"      ", (short *)"      ",
  1840.   (short *)"      ", (short *)"      ", (short *)"      ", (short *)"      ",
  1841.   (short *)"      ", (short *)"      ", (short *)"      ", (short *)"      ",
  1842.   (short *)"      ", (short *)"      ", (short *)"      ", (short *)"      ",
  1843.   (short *)"      ", (short *)"      ", (short *)"      ", (short *)"      ",
  1844.   (short *)"      ", (short *)"      ", (short *)"      ", (short *)"      ",
  1845.   (short *)"      ", (short *)"      ", (short *)"      ", (short *)"      "
  1846. };
  1847.  
  1848. static long sizeof_ofiles[] =
  1849. { 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
  1850.   0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
  1851.   0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
  1852.   0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L
  1853. };
  1854.  
  1855. long *link_sizeof_ofiles[] =
  1856. { &sizeof_ofiles[ 0], &sizeof_ofiles[ 1], &sizeof_ofiles[ 2], &sizeof_ofiles[ 3],
  1857.   &sizeof_ofiles[ 4], &sizeof_ofiles[ 5], &sizeof_ofiles[ 6], &sizeof_ofiles[ 7],
  1858.   &sizeof_ofiles[ 8], &sizeof_ofiles[ 9], &sizeof_ofiles[10], &sizeof_ofiles[11],
  1859.   &sizeof_ofiles[12], &sizeof_ofiles[13], &sizeof_ofiles[14], &sizeof_ofiles[15],
  1860.   &sizeof_ofiles[16], &sizeof_ofiles[17], &sizeof_ofiles[18], &sizeof_ofiles[19],
  1861.   &sizeof_ofiles[20], &sizeof_ofiles[21], &sizeof_ofiles[22], &sizeof_ofiles[23],
  1862.   &sizeof_ofiles[24], &sizeof_ofiles[25], &sizeof_ofiles[26], &sizeof_ofiles[27],
  1863.   &sizeof_ofiles[28], &sizeof_ofiles[29], &sizeof_ofiles[30], &sizeof_ofiles[31],
  1864.   &sizeof_ofiles[32], &sizeof_ofiles[33], &sizeof_ofiles[34], &sizeof_ofiles[35],
  1865.   &sizeof_ofiles[36], &sizeof_ofiles[37], &sizeof_ofiles[38], &sizeof_ofiles[39],
  1866.   &sizeof_ofiles[40], &sizeof_ofiles[41], &sizeof_ofiles[42], &sizeof_ofiles[43],
  1867.   &sizeof_ofiles[44], &sizeof_ofiles[45], &sizeof_ofiles[46], &sizeof_ofiles[47],
  1868.   &sizeof_ofiles[48], &sizeof_ofiles[49], &sizeof_ofiles[50], &sizeof_ofiles[51],
  1869.   &sizeof_ofiles[52], &sizeof_ofiles[53], &sizeof_ofiles[54], &sizeof_ofiles[55],
  1870.   &sizeof_ofiles[56], &sizeof_ofiles[57], &sizeof_ofiles[58], &sizeof_ofiles[59],
  1871.   &sizeof_ofiles[60], &sizeof_ofiles[61], &sizeof_ofiles[62], &sizeof_ofiles[63]
  1872. };
  1873.  
  1874. long link_nb_ofiles;
  1875.  
  1876. long prog_len;
  1877.  
  1878.  
  1879. long start_real_time;
  1880.  
  1881.  
  1882. long os_nb_processors()
  1883. { return 1;
  1884. }
  1885.  
  1886.  
  1887. long os_fork_on_processors( n )
  1888. long n;
  1889. { return 0;
  1890. }
  1891.  
  1892.  
  1893. void os_shared_malloc8( len, processor, cont )
  1894. long len;
  1895. long processor;
  1896. void (*cont)();
  1897. { long appl_limit = (((long)&appl_limit) - len - ((long)MAC_STACK_LEN_IN_K)*K) & -4L;
  1898.   long lim = ((long)ApplZone) + ((long)MAC_HEAP_LEN_IN_K)*K;
  1899.   if (lim < ((long)HeapEnd)+1024) lim = ((long)HeapEnd)+1024;
  1900.   if (appl_limit < lim)
  1901.     cont( (long)NULL );
  1902.   else
  1903.   { SetApplLimit( (void *)appl_limit );
  1904.     asm
  1905.     { move.l cont,a0
  1906.       move.l sp,d0
  1907.       move.l d0,d1
  1908.       sub.l  len,d1
  1909.       and.w  #-8,d1
  1910.       move.l d1,sp
  1911.       move.l d0,-(sp)
  1912.       move.l d1,-(sp)
  1913.       jsr    (a0)
  1914.       move.l 4(sp),sp
  1915.     }
  1916.   }
  1917. }
  1918.  
  1919.  
  1920. void os_shared_copy_malloc8( len_share, len_copy, processor, cont )
  1921. long len_share, len_copy;
  1922. long processor;
  1923. void (*cont)();
  1924. { long aligned_len_share = ceiling8( len_share );
  1925.   long len = aligned_len_share + len_copy;
  1926.   long offs = aligned_len_share - len_share;
  1927.   long appl_limit = (((long)&appl_limit) - len - ((long)MAC_STACK_LEN_IN_K)*K) & -4L;
  1928.   long lim = ((long)ApplZone) + ((long)MAC_HEAP_LEN_IN_K)*K;
  1929.   if (lim < ((long)HeapEnd)+1024) lim = ((long)HeapEnd)+1024;
  1930.   if (appl_limit < lim)
  1931.     cont( (long)NULL );
  1932.   else
  1933.   { SetApplLimit( (void *)appl_limit );
  1934.     asm
  1935.     { move.l offs,d2
  1936.       move.l cont,a0
  1937.       move.l sp,d0
  1938.       move.l d0,d1
  1939.       sub.l  len,d1
  1940.       and.w  #-8,d1
  1941.       move.l d1,sp
  1942.       move.l d0,-(sp)
  1943.       add.l  d2,d1
  1944.       move.l d1,-(sp)
  1945.       jsr    (a0)
  1946.       move.l 4(sp),sp
  1947.     }
  1948.   }
  1949. }
  1950.  
  1951.  
  1952. void os_block_copy( src, dst, len )
  1953. char *src, *dst;
  1954. long len;
  1955. { register char *p1 = src, *p2 = dst;
  1956.   register long i = len;
  1957.   while (i > 0) { *(p2++) = *(p1++); i--; }
  1958. }
  1959.  
  1960.  
  1961. void os_flush_caches()
  1962. { if (gHasHWPriv)
  1963.   asm
  1964.   { moveq #1,d0
  1965.     dc.w _HWPriv
  1966.   }
  1967.   else if (os_M68020)
  1968.   {
  1969. #define INSTR_CACHE_LENGTH_IN_K 64
  1970. #define DATA_CACHE_LENGTH_IN_K  8
  1971.  
  1972.     short *start = (short *)pstate->heap_old;
  1973.     short *p = start;
  1974.     long i;
  1975.  
  1976.     for (i=((long)INSTR_CACHE_LENGTH_IN_K)*K/2-1; i>0; i--) *p++ = NOP_OP;
  1977.     *p++ = RTS_OP;
  1978.     for (i=((long)DATA_CACHE_LENGTH_IN_K)*K/2; i>0; i--) *p++ = 0;
  1979.  
  1980.     ((void (*)())start)();
  1981.   }
  1982. }
  1983.  
  1984.  
  1985. void os_flush_writes()
  1986. { if (gHasHWPriv)
  1987.   asm
  1988.   { moveq #1,d0
  1989.     dc.w _HWPriv
  1990.   }
  1991. }
  1992.  
  1993.  
  1994. long os_clock()
  1995. { return TickCount() - start_real_time;
  1996. }
  1997.  
  1998.  
  1999. long os_real_time_clock()
  2000. { return TickCount() - start_real_time;
  2001. }
  2002.  
  2003.  
  2004. long os_clock_to_msec( ticks )
  2005. long ticks;
  2006. { return ticks * 1000 / TICKS_PER_SEC;
  2007. }
  2008.  
  2009.  
  2010. void os_cpu_times( buf )
  2011. long *buf;
  2012. { buf[0] = (TickCount() - start_real_time) * 1000 / TICKS_PER_SEC;
  2013.   buf[1] = 0;
  2014. }
  2015.  
  2016.  
  2017. void os_profil( buff, bufsiz, offset, shift )
  2018. short *buff;
  2019. long bufsiz, offset;
  2020. long shift;
  2021. {
  2022. }
  2023.  
  2024.  
  2025. long os_ticks_to_msec( ticks )
  2026. long ticks;
  2027. { return ticks * 1000 / TICKS_PER_SEC;
  2028. }
  2029.  
  2030.  
  2031. static void fatal_signal( pc, sp, kind )
  2032. long pc, sp;
  2033. char *kind;
  2034. { os_warn( "Fatal signal %s, terminating...\n", (long)kind );
  2035.   os_quit();
  2036. }
  2037.  
  2038.  
  2039. void os_install_trap_handlers( intr_proc, timer_proc, io_proc, fatal_proc )
  2040. void (*intr_proc)();
  2041. void (*timer_proc)();
  2042. void (*io_proc)();
  2043. void (*fatal_proc)();
  2044. { intr_action = intr_proc;
  2045.   timer_action = timer_proc;
  2046.   io_action = io_proc;
  2047.   if (fatal_proc != (void (*)())0)
  2048.     fatal_action = fatal_proc;
  2049.   else
  2050.     fatal_action = fatal_signal;
  2051.  
  2052.   if (loading_dp != NULL)
  2053.   { DisposDialog( loading_dp ); loading_dp = NULL; }
  2054.  
  2055.   MaxApplZone();
  2056.  
  2057.   start_intr_task();
  2058. }
  2059.  
  2060.  
  2061. long os_get_next_event( event )
  2062. EventRecord *event;
  2063. { long result = 0;
  2064.   GrafPtr save;
  2065.   GetPort( &save );
  2066.   if (do_tasks())
  2067.   { if (gHasWNE)
  2068.       { result = (long)( gInBackground ? gWaitTicksBG    /* 22Jul92  e   -- added gMaxSleep */
  2069.                                          : (long )( (gWaitTicksFG > gMaxSleep) ? gMaxSleep
  2070.                                                                                 : gWaitTicksFG) );
  2071.       result = WaitNextEvent( everyEvent, event, result, gCursorRgn );
  2072.     }
  2073.     else
  2074.     { SystemTask();
  2075.       result = GetNextEvent( everyEvent, event );
  2076.     }
  2077.   }
  2078.   SetPort( save );
  2079.   return result;
  2080. }
  2081.  
  2082. long os_handle_event( event )
  2083. EventRecord *event;
  2084. { long result;
  2085.   GrafPtr save;
  2086.   GetPort( &save );
  2087.   result = handle_event( event );
  2088.   SetPort( save );
  2089.   return result;
  2090. }
  2091.  
  2092.  
  2093. char *os_expand_filename( str )
  2094. char *str;
  2095. { return str;
  2096. }
  2097.  
  2098.  
  2099. struct {
  2100.   short type; /* -1 = not in use, 0 = text file, 1 = bin file, 2 = resource, 3 = window */
  2101.   long pos;
  2102.   short refnum;
  2103.   } os_file[MAX_NB_OPEN_FILES];
  2104.  
  2105.  
  2106. short appl_res_file;
  2107. Handle appl_res_map;
  2108.  
  2109. static short read_resource( type, id, n, ptr )  /* Ugly, but works... */
  2110. ResType type;
  2111. short id;
  2112. long n;
  2113. char *ptr;
  2114. { short i, j;
  2115.   long count;
  2116.   struct type_list_rec { short id, name_offs; long data_offs, reserved; };
  2117.   struct map_entry_rec { ResType type; short nb_minus_1; short offs; };
  2118.   struct map_rec
  2119.   { char pad[24]; short type_list_offs, name_list_offs, nb_minus_1;
  2120.     struct map_entry_rec entry[1];
  2121.   };
  2122.   struct map_rec *map = (struct map_rec *)*appl_res_map;
  2123.  
  2124.   i = map->nb_minus_1;
  2125.   while (i >= 0)
  2126.   { if (map->entry[i].type == type)
  2127.     { struct type_list_rec *item = (struct type_list_rec *)(((char *)map)+map->type_list_offs+map->entry[i].offs);
  2128.       j = map->entry[i].nb_minus_1;
  2129.       while (j >= 0)
  2130.       { if (item[j].id == id)
  2131.         { if (SetFPos( appl_res_file, 1, item[j].data_offs + 260L ) != noErr) return 0;
  2132.           count = n;
  2133.           if (FSRead( appl_res_file, &count, ptr ) != noErr) return 0;
  2134.           return 1;
  2135.         }
  2136.         j--;
  2137.       }
  2138.     }
  2139.     i--;
  2140.   }
  2141.   return 0;
  2142. }
  2143.  
  2144.  
  2145. static long file_open( name, for_output )
  2146. char *name;
  2147. long for_output;
  2148. { long i;
  2149.   for (i=0; i<(long)MAX_NB_OPEN_FILES; i++) if (os_file[i].type < 0) break;
  2150.   if (i == (long)MAX_NB_OPEN_FILES) return -1;
  2151.  
  2152.   if (name[0] == 1) /* opening 'gamO' resource */
  2153.   { Handle h;
  2154.     short j = 1, n = 0;
  2155.     EventRecord event;
  2156.     while (os_get_next_event( &event )) os_handle_event( &event );
  2157.     if (for_output) return -1;
  2158.     while ((name[j]>='0') && (name[j]<='9')) n = n*10 + (name[j++] - '0');
  2159.     SetResLoad( FALSE );
  2160.     h = GetResource( 'gamO', n );
  2161.     SetResLoad( TRUE );
  2162.     if (h == NULL) return -1;
  2163.     ReleaseResource( h );
  2164.     os_file[i].type   = 2;
  2165.     os_file[i].refnum = n;
  2166.     os_file[i].pos    = 0;
  2167.   }
  2168.   else if (name[0] == 2) /* opening window */
  2169.   { GrafPtr save;
  2170.     GetPort( &save );
  2171.     os_file[i].refnum = wind_open( name+1, TRUE, TRUE, TRUE );
  2172.     if (os_file[i].refnum < 0) i = -1; else os_file[i].type = 3;
  2173.     SetPort( save );
  2174.   }
  2175.   else
  2176.   { short io;
  2177.     short bin, len;
  2178.     Str255 pname;
  2179.     c_to_p( name, pname );
  2180.     len = (unsigned char)pname[0];
  2181.     bin = ((len >= 2) && (pname[len-1] == '.') && (pname[len] == 'O'));
  2182.     os_file[i].refnum = open_file( pname, (short)for_output, !bin, &io );
  2183.     if (os_file[i].refnum == -1) return -1;
  2184.     os_file[i].type = bin;
  2185.   }
  2186.  
  2187.   return i;
  2188. }
  2189.  
  2190. OS_FILE os_file_open_input( name )
  2191. char *name;
  2192. { return (OS_FILE)file_open( name, 0L );
  2193. }
  2194.  
  2195.  
  2196. OS_FILE os_file_open_output( name )
  2197. char *name;
  2198. { return (OS_FILE)file_open( name, 1L );
  2199. }
  2200.  
  2201.  
  2202. OS_FILE os_file_open_input_output( name )
  2203. char *name;
  2204. { return (OS_FILE)file_open( name, 1L );
  2205. }
  2206.  
  2207.  
  2208. long os_file_length( f )
  2209. OS_FILE f;
  2210. { long len;
  2211.   switch (os_file[f].type)
  2212.   { case 0:
  2213.     case 1:
  2214.     { if (GetEOF( os_file[f].refnum, &len ) != noErr) return -1;
  2215.       break;
  2216.     }
  2217.     case 2:
  2218.     { Handle h;
  2219.       SetResLoad( FALSE );
  2220.       h = GetResource( 'gamO', os_file[f].refnum );
  2221.       SetResLoad( TRUE );
  2222.       if (h == NULL) return -1;
  2223.       len = SizeResource( h );
  2224.       ReleaseResource( h );
  2225.       break;
  2226.     }
  2227.     case 3:
  2228.       return -1;
  2229.     default:
  2230.       return -1;
  2231.   }
  2232.   return len;
  2233. }
  2234.  
  2235.  
  2236. long os_file_read_ready( f )
  2237. OS_FILE f;
  2238. { if (os_file[f].type == 3)
  2239.   { short id = os_file[f].refnum;
  2240.     return ((wind_table[id].len - wind_table[id].pos) > 0);
  2241.   }
  2242.   else
  2243.     return 1;
  2244. }
  2245.  
  2246.  
  2247. long os_file_write_ready( f )
  2248. OS_FILE f;
  2249. { return 1;
  2250. }
  2251.  
  2252.  
  2253. void os_file_block_read( f )
  2254. OS_FILE f;
  2255. {
  2256. }
  2257.  
  2258.  
  2259. void os_file_block_write( f )
  2260. OS_FILE f;
  2261. {
  2262. }
  2263.  
  2264.  
  2265. long os_file_read( f, ptr, n )
  2266. OS_FILE f;
  2267. char *ptr;
  2268. long n;
  2269. { switch (os_file[f].type)
  2270.   { case 0:
  2271.     case 1:
  2272.     { long count = n;
  2273.       FSRead( os_file[f].refnum, &count, ptr );
  2274.       if (os_file[f].type == 0)
  2275.       { register char *p = ptr;
  2276.         register long len = count;
  2277.         while (len-- > 0) { if (*p == '\r') *p = '\n'; p++; }
  2278.       }
  2279.       return count;
  2280.     }
  2281.     case 2:
  2282.       if (read_resource( 'gamO', os_file[f].refnum, n, ptr ))
  2283.         return n;
  2284.       else
  2285.         return -2;
  2286.     case 3:
  2287.     { long result;
  2288.       GrafPtr save;
  2289.       GetPort( &save );
  2290.       result = wind_read( os_file[f].refnum, ptr, n );
  2291.       SetPort( save );
  2292.       return result;
  2293.     }
  2294.     default:
  2295.       return -2;
  2296.   }
  2297. }
  2298.  
  2299.  
  2300. long os_file_write( f, ptr, n )
  2301. OS_FILE f;
  2302. char *ptr;
  2303. long n;
  2304. { switch (os_file[f].type)
  2305.   { case 0:
  2306.     { char buffer[1024+8];
  2307.       register char *p1 = ptr, *p2 = ptr+n;
  2308.       register short len = 0;
  2309.  
  2310.       while (p1<p2)
  2311.       { register char c = *p1++;
  2312.         if (c == '\n') buffer[len++] = '\r'; else buffer[len++] = c;
  2313.         if (len == 1024)
  2314.         { long count = len;
  2315.           FSWrite( os_file[f].refnum, &count, buffer );
  2316.           if (count != len) return (p1-ptr)-len+count;
  2317.           len = 0;
  2318.         }
  2319.       }
  2320.       if (len > 0)
  2321.       { long count = len;
  2322.         FSWrite( os_file[f].refnum, &count, buffer );
  2323.         if (count != len) return (p1-ptr)-len+count;
  2324.       }
  2325.       return (p1-ptr);
  2326.     }
  2327.     case 1:
  2328.     { long count = n;
  2329.       FSWrite( os_file[f].refnum, &count, ptr );
  2330.       return count;
  2331.     }
  2332.     case 2:
  2333.       return -2;
  2334.     case 3:
  2335.     { long result;
  2336.       GrafPtr save;
  2337.       GetPort( &save );
  2338.       result = wind_write( os_file[f].refnum, ptr, n );
  2339.       SetPort( save );
  2340.       return result;
  2341.     }
  2342.     default:
  2343.       return -2;
  2344.   }
  2345. }
  2346.  
  2347.  
  2348. long os_file_close( f )
  2349. OS_FILE f;
  2350. { switch (os_file[f].type)
  2351.   { case 0:
  2352.     case 1:
  2353.     { short io;
  2354.       os_file[f].type = -1;
  2355.       if (close_file( os_file[f].refnum, &io )) return -1;
  2356.       return 0;
  2357.     }
  2358.     case 2:
  2359.     { os_file[f].type = -1;
  2360.       return 0;
  2361.     }
  2362.     case 3:
  2363.     { long result = 0;
  2364.       GrafPtr save;
  2365.       GetPort( &save );
  2366.       if (os_file[f].refnum < 0)
  2367.         result = -1;
  2368.       else
  2369.       { if (os_file[f].refnum != interaction_id) os_file[f].type = -1;
  2370.         wind_close( os_file[f].refnum );
  2371.       }
  2372.       SetPort( save );
  2373.       return result;
  2374.     }
  2375.     default:
  2376.       return -1;
  2377.   }
  2378. }
  2379.  
  2380.  
  2381. extern void os_set_timer_interval( interval )
  2382. long interval;
  2383. { intr_task_interval = (interval * TICKS_PER_SEC + 999) / 1000;
  2384. }
  2385.  
  2386.  
  2387. void os_quit()
  2388. { short i;
  2389.   long ticks;
  2390.   stop_intr_task();
  2391.   for (i=MAX_NB_OPEN_FILES-1; i>0; i--) os_file_close( (OS_FILE)i );
  2392.   if (abnormal_exit)
  2393.   { for (i=0; i<3; i++) { SysBeep(3); Delay( 3, &ticks ); }
  2394.     Delay( 60, &ticks );
  2395.   }
  2396.   wind_end();
  2397.   help_end();
  2398.   ExitToShell();
  2399. }
  2400.  
  2401.  
  2402. static void os_notify_gc_begin_internal()
  2403. { SetCursor( &gc_cursor );
  2404. }
  2405.  
  2406.  
  2407. static void os_notify_gc_end_internal()
  2408. { SetCursor( current_cursor );
  2409. }
  2410.  
  2411.  
  2412. extern void main_gambit();
  2413.  
  2414.  
  2415. #define MAX_ARGS 2
  2416.  
  2417. static short main_internal( argc, argv, envp )
  2418. short argc;
  2419. char *argv[], *envp[];
  2420. { char new_args[256];
  2421.   short new_argc;
  2422.   char *new_argv[MAX_ARGS+1];
  2423.   char *new_envp[] = { "MAC", NULL };
  2424.   SysEnvRec sysenv;
  2425.   Handle h;
  2426.   short i;
  2427.   long ofiles_len;
  2428.   DialogPtr dp;
  2429.   THz heap = ApplicZone();
  2430.  
  2431.   appl_res_file = CurResFile();
  2432.   appl_res_map = TopMapHndl;
  2433.  
  2434.   MoreMasters();
  2435.   MoreMasters();
  2436.   MoreMasters();
  2437.   MoreMasters();
  2438.   CouldAlert( ok_alertID );
  2439.   SetGrowZone( mem_full_err );
  2440.  
  2441.   InitGraf( &thePort );
  2442.   InitFonts();
  2443.   FlushEvents( everyEvent, 0 );
  2444.   InitWindows();
  2445.   InitMenus();
  2446.   TEInit();
  2447.   eTeInit();
  2448.   InitDialogs( 0L );
  2449.   InitCursor();
  2450.  
  2451.   GetVol( new_args, ¤t_volume );
  2452.   if (!getfullpathfromcurrentvolume( CurApName, new_args, 256, 0 ))
  2453.     p_to_c( CurApName, new_args );
  2454.  
  2455.   help_begin( "\pOnline Help", CurApName );
  2456.  
  2457.   wind_begin();
  2458.  
  2459.   new_argc = 0;
  2460.   new_argv[new_argc++] = new_args;
  2461.   new_argv[new_argc] = NULL;
  2462.  
  2463.   for (i=0; i<MAX_NB_OPEN_FILES; i++) os_file[i].type = -1;
  2464.   os_file[0].type   = 3;
  2465.   os_file[0].refnum = wind_open( "Interaction", FALSE, FALSE, TRUE );
  2466.   interaction_id = os_file[0].refnum;
  2467.   if (interaction_id < 0) os_quit();
  2468.   delWindMenuItem( interaction_id );
  2469.  
  2470.   i = 128;
  2471.   ofiles_len = 0;
  2472.   link_nb_ofiles = 0;
  2473.   again:
  2474.   SetResLoad( FALSE ); h = GetResource( 'gamO', i ); SetResLoad( TRUE );
  2475.   if (h != NULL)
  2476.   { short j = 0, d = 10000, n = i;
  2477.     ((char *)link_ofiles[link_nb_ofiles])[j++] = 1;
  2478.     while (d>0)
  2479.     { ((char *)link_ofiles[link_nb_ofiles])[j++] = n/d + '0'; n = n%d; d = d/10; }
  2480.     ((char *)link_ofiles[link_nb_ofiles])[j++] = '\0';
  2481.     ofiles_len += SizeResource(h);
  2482.     ReleaseResource( h );
  2483.     link_nb_ofiles++;
  2484.     i++;
  2485.     goto again;
  2486.   }
  2487.  
  2488.   { short msg, count;
  2489.     CountAppFiles( &msg, &count );
  2490.     if (msg == appOpen)
  2491.     { for (i=1; i<=count; i++)
  2492.       { char path[FILENAME_LEN];
  2493.         AppFile file_info;
  2494.         GetAppFiles( i, &file_info );
  2495.         if ((file_info.fType == 'TEXT') &&
  2496.             getfullpathfromwd( (long)file_info.vRefNum, (StringPtr)file_info.fName, path, FILENAME_LEN, 1 ))
  2497.         { if (edit( path, 0L, 0L ) < 0) break;
  2498.           current_volume = file_info.vRefNum;
  2499.           ClrAppFiles( i );
  2500.         }
  2501.         else if (file_info.fType == 'gamO')
  2502.         { char *ofile;
  2503.           long count;
  2504.           short refnum;
  2505.           short io;
  2506.           io = FSOpen( file_info.fName, file_info.vRefNum, &refnum );
  2507.           if (io != noErr) { io_err( io ); return 0; }
  2508.           io = GetEOF( refnum, &prog_len );
  2509.           if (io != noErr) { FSClose( refnum ); io_err( io ); return 0; }
  2510.           ofile = NewPtr( prog_len );
  2511.           if (ofile == NULL) return 0;
  2512.           count = prog_len;
  2513.           io = FSRead( refnum, &count, ofile );
  2514.           if ((io != noErr) || (count != prog_len)) { FSClose( refnum ); io_err( io ); return 0; }
  2515.           FSClose( refnum );
  2516.           link_ofiles[link_nb_ofiles-1] = (short *)ofile;
  2517.           link_sizeof_ofiles[link_nb_ofiles-1] = &prog_len;
  2518.           ofiles_len += prog_len;
  2519.           current_volume = file_info.vRefNum;
  2520.           ClrAppFiles( i );
  2521.           break;
  2522.         }
  2523.       }
  2524.     }
  2525.   }
  2526.  
  2527.   SysEnvirons( curSysEnvVers, &sysenv );
  2528.   os_M68020 = (sysenv.processor >= env68020);
  2529.   os_M68881 = sysenv.hasFPU;
  2530.   os_stdin  = 0;
  2531.   os_stdout = 0;
  2532.   os_stderr = 0;
  2533.  
  2534.   start_real_time = TickCount();
  2535.  
  2536.   SetCursor( current_cursor );
  2537.  
  2538.   ParamText1( "\p" );
  2539.   loading_dp = GetNewDialog( loading_dlogID, 0L, (WindowPtr)-1L );
  2540.   if (loading_dp != NULL) DrawDialog( loading_dp );
  2541.  
  2542.   partition_init( ofiles_len );
  2543.  
  2544.   main_gambit( new_argc, new_argv, new_envp );
  2545.  
  2546.   os_quit();
  2547.  
  2548.   return 0;
  2549. }
  2550.  
  2551. /* 6Jul92  e */
  2552. #ifdef THINK_C
  2553. #include "os.c"
  2554. #endif
  2555.  
  2556. /*--------------------------------------------------------------------------*/
  2557.